1723 files changed, 477208 insertions, 504707 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
index 0ec6eb319ee..e69de29bb2d 100644
--- a/.github/PULL_REQUEST_TEMPLATE
+++ b/.github/PULL_REQUEST_TEMPLATE
@@ -1,33 +0,0 @@
-Many thanks for your interest in improving GlusterFS!
-
-GlusterFS does not use GitHub Pull-Requests. Instead, changes are reviewed
-on the Gerrit instance of the Gluster Community at https://review.gluster.org
-
-In order to send your changes for review, follow these steps:
-
-1. login on https://review.gluster.org with your GitHub account
-2. add a public ssh-key to your profile on https://review.gluster.org/#/settings/ssh-keys
-3. add the Gerrit remote to your locally cloned git repository
-
-   $ git remote add gerrit ssh://$USER@review.gluster.org/glusterfs.git
-
-4. configure the commit hooks
-
-   $ git review --setup
-
-5. post your changes to Gerrit
-
-   $ git review
-
-
-You may need to install the 'git-review' package if 'git review' is not
-available. Note that the hooks for the repository make sure to add a ChangeId
-label in the commit messages. Gerrit uses the ChangeId to track single patches
-and its updated versions.
-
-For more details, see the documented development workflow at
-  http://gluster.readthedocs.io/en/latest/Developer-guide/Simplified-Development-Workflow/
-
-If there are any troubles or difficulties with these instructions, please
-contact us on gluster-devel@gluster.org or on Freenode IRC in the #gluster-dev
-channel.
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 899758efe68..fc5ba586f8e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,10 +29,12 @@ test-driver
 *.patch
 .libs
 .deps
+.dirstamp
 
 # Softlinks to test and log
 log
 *.vol
+.clang-format
 
 # cmocka unit tests
 *.log
@@ -59,6 +61,7 @@ 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
@@ -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
@@ -129,3 +121,5 @@ 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/.testignore b/.testignore
index 9e75d56a94a..fe8f838bf2b 100644
--- a/.testignore
+++ b/.testignore
@@ -1,11 +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
@@ -31,6 +34,8 @@ extras/cliutils/README.md
 extras/command-completion/README
 extras/create_new_xlator/README.md
 extras/glusterfs.vim
+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
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/MAINTAINERS b/MAINTAINERS
index b7a4e6c443f..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,53 +172,44 @@ 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: Shreyas Siravara <sshreyas@fb.com>
-M: Jeff Darcy <jeff@pl.atyp.us>
-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/
 
@@ -254,12 +219,6 @@ 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>
@@ -274,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/
@@ -289,49 +247,24 @@ M: Susant Kumar Palai <spalai@redhat.com>
 S: Maintained
 F: xlators/features/cloudsync/
 
-Experimental Features:
-----------------------
-
-RIO-Distribution
-M: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Kotresh HR <khiremat@redhat.com>
-P: Susant 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/
-
-
 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/
 
@@ -343,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/
@@ -363,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/
@@ -407,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/
@@ -429,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
@@ -446,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
@@ -464,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
@@ -481,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
@@ -491,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
@@ -520,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>
@@ -551,7 +446,6 @@ Testing - Glusto-Tests
 M: Jonathan Holloway <jholloway@redhat.com>
 M: Vijay Bhaskar Reddy Avuthu <vavuthu@redhat.com>
 M: Akarsha Rai <akrai@redhat.com>
-P: Nigel Babu <nigelb@redhat.com>
 S: Maintained
 T: https://github.com/gluster/glusto-tests.git
 
@@ -566,16 +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>
 M: Deepshikha Khandelwal <dkhandel@redhat.com>
-P: Kaushal M <kaushal@redhat.com>
 P: Niels de Vos <ndevos@redhat.com>
 
 Special Thanks
@@ -583,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>
@@ -604,3 +506,5 @@ 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 f5af4220647..98ea5c1038d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,28 +3,29 @@ SOURCES = site.h
 EXTRA_DIST = autogen.sh \
 	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/umountd \
+	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 \
-	contrib/umountd/Makefile
+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
 
@@ -52,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 ff8804d0b81..9d68e033782 100644
--- a/README.md
+++ b/README.md
@@ -3,8 +3,7 @@
   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](http://docs.gluster.org/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://docs.gluster.org).
@@ -12,6 +11,32 @@
 ## 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 9a5dd0d290a..3b2c8ab5a15 100755
--- a/api/examples/getvolfile.py
+++ b/api/examples/getvolfile.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
 import ctypes
diff --git a/api/examples/glfsxmp.c b/api/examples/glfsxmp.c
index 9bfb1d2a81f..a55616ef739 100644
--- a/api/examples/glfsxmp.c
+++ b/api/examples/glfsxmp.c
@@ -6,1593 +6,1806 @@
 #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 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);
+    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: 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;
-                }
-        }
+    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 3d25823925b..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) $(GF_LDFLAGS) \
-	$(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 15f9945c5ed..b9223940416 100644
--- a/api/src/gfapi-messages.h
+++ b/api/src/gfapi-messages.h
@@ -11,7 +11,7 @@
 #ifndef _GFAPI_MESSAGES_H__
 #define _GFAPI_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.
  *
@@ -23,61 +23,125 @@
  * glfs-message-id.h.
  */
 
-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
-);
+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 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 854a7d42f8f..bc639e6b99f 100644
--- a/api/src/gfapi.aliases
+++ b/api/src/gfapi.aliases
@@ -167,24 +167,35 @@ _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_recall_lease_fd _glfs_recall_lease_fd$GFAPI_future
-_pub_glfs_recall_lease_upcall _glfs_recall_lease_upcall$GFAPI_future
-_pub_glfs_read_async _glfs_read_async$GFAPI_future
-_pub_glfs_write_async _glfs_write_async$GFAPI_future
-_pub_glfs_readv_async _glfs_readv_async$GFAPI_future
-_pub_glfs_writev_async _glfs_writev_async$GFAPI_future
-_pub_glfs_pread _glfs_pread$GFAPI_future
-_pub_glfs_pwrite _glfs_pwrite$GFAPI_future
-_pub_glfs_pread_async _glfs_pread_async$GFAPI_future
-_pub_glfs_pwrite_async _glfs_pwrite_async$GFAPI_future
-_pub_glfs_preadv_async _glfs_preadv_async$GFAPI_future
-_pub_glfs_pwritev_async _glfs_pwritev_async$GFAPI_future
-_pub_glfs_fsync _glfs_fsync$GFAPI_future
-_pub_glfs_fsync_async _glfs_fsync_async$GFAPI_future
-_pub_glfs_fdatasync _glfs_fdatasync$GFAPI_future
-_pub_glfs_fdatasync_async _glfs_fdatasync_async$GFAPI_future
-_pub_glfs_ftruncate _glfs_ftruncate$GFAPI_future
-_pub_glfs_ftruncate_async _glfs_ftruncate_async$GFAPI_future
-_pub_glfs_discard_async _glfs_discard_async$GFAPI_future
-_pub_glfs_zerofill_async _glfs_zerofill_async$GFAPI_future
+_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 29a25fbf2e4..228ac47c084 100644
--- a/api/src/gfapi.map
+++ b/api/src/gfapi.map
@@ -24,14 +24,30 @@ GFAPI_3.4.0 {
 		glfs_set_xlator_option;
 		glfs_read;
 		glfs_write;
+		glfs_read_async;
+		glfs_write_async;
 		glfs_readv;
 		glfs_writev;
+		glfs_readv_async;
+		glfs_writev_async;
+		glfs_pread;
+		glfs_pwrite;
+		glfs_pread_async;
+		glfs_pwrite_async;
 		glfs_preadv;
 		glfs_pwritev;
+		glfs_preadv_async;
+		glfs_pwritev_async;
 		glfs_lseek;
+		glfs_ftruncate;
+		glfs_ftruncate_async;
 		glfs_lstat;
 		glfs_stat;
 		glfs_fstat;
+		glfs_fsync;
+		glfs_fsync_async;
+		glfs_fdatasync;
+		glfs_fdatasync_async;
 		glfs_access;
 		glfs_symlink;
 		glfs_readlink;
@@ -71,20 +87,9 @@ GFAPI_3.4.0 {
 		glfs_getcwd;
 		glfs_chdir;
 		glfs_fchdir;
+		glfs_realpath;
 		glfs_posix_lock;
 		glfs_dup;
-		glfs_pread;
-		glfs_pwrite;
-		glfs_pread_async;
-		glfs_pwrite_async;
-		glfs_ftruncate;
-		glfs_ftruncate_async;
-		glfs_fsync;
-		glfs_fsync_async;
-		glfs_fdatasync;
-		glfs_fdatasync_async;
-		glfs_realpath;
-		glfs_h_lookupat;
 } GFAPI_PRIVATE_3.4.0;
 
 GFAPI_3.4.2 {
@@ -119,7 +124,9 @@ GFAPI_3.5.0 {
 		glfs_readdirplus;
 		glfs_fallocate;
 		glfs_discard;
+		glfs_discard_async;
 		glfs_zerofill;
+		glfs_zerofill_async;
 		glfs_caller_specific_init;
 		glfs_h_setxattrs;
 } GFAPI_3.4.2;
@@ -201,7 +208,7 @@ 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 {
@@ -210,38 +217,67 @@ GFAPI_PRIVATE_3.12.0 {
 } GFAPI_3.11.0;
 
 GFAPI_3.13.0 {
-        global:
-                glfs_upcall_register;
-                glfs_upcall_unregister;
+	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;
+	global:
+		glfs_setfsleaseid;
+		glfs_file_lock;
+		glfs_lease;
+		glfs_h_lease;
 } GFAPI_3.13.0;
 
-GFAPI_future {
-	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;
+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 870b287c2a7..6aa3c5602d1 100644
--- a/api/src/glfs-fops.c
+++ b/api/src/glfs-fops.c
@@ -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,25 +32,30 @@
 #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);
+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);
+    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 useful for all async fops. There is chance that glfd is
@@ -60,33 +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;
+    gf_boolean_t ret = _gf_false;
 
-        LOCK (&glfd->lock);
-        {
-                if (glfd->state != GLFD_CLOSE)
-                        ret = _gf_true;
-        }
-        UNLOCK (&glfd->lock);
+    LOCK(&glfd->lock);
+    {
+        if (glfd->state != GLFD_CLOSE)
+            ret = _gf_true;
+    }
+    UNLOCK(&glfd->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-glfd_set_state_bind (struct glfs_fd *glfd)
+glfd_set_state_bind(struct glfs_fd *glfd)
 {
-        LOCK (&glfd->lock);
-        {
-                glfd->state = GLFD_OPEN;
-        }
-        UNLOCK (&glfd->lock);
+    LOCK(&glfd->lock);
+    {
+        glfd->state = GLFD_OPEN;
+    }
+    UNLOCK(&glfd->lock);
 
-        fd_bind (glfd->fd);
-        glfs_fd_bind (glfd);
+    fd_bind(glfd->fd);
+    glfs_fd_bind(glfd);
 
-        return;
+    return;
 }
 
 /*
@@ -97,5200 +103,5830 @@ glfd_set_state_bind (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_get_upcall_lease (struct gf_upcall *to_up_data,
-                             struct gf_upcall *from_up_data)
+glfs_get_upcall_lease(struct gf_upcall *to_up_data,
+                      struct gf_upcall *from_up_data)
 {
+    struct gf_upcall_recall_lease *ca_data = NULL;
+    struct gf_upcall_recall_lease *f_ca_data = NULL;
+    int ret = -1;
 
-        struct gf_upcall_recall_lease *ca_data = NULL;
-        struct gf_upcall_recall_lease *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->lease_type   = f_ca_data->lease_type;
-        gf_uuid_copy (ca_data->tid, f_ca_data->tid);
-        ca_data->dict       = f_ca_data->dict;
+    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;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 int
-glfs_loc_link (loc_t *loc, struct iatt *iatt)
+glfs_loc_link(loc_t *loc, struct iatt *iatt)
 {
-	int ret = -1;
-        inode_t *old_inode = NULL;
-        uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+    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 (!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;
+    }
 
-        /* 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;
+}
 
-	return ret;
+void
+glfs_iatt_to_stat(struct glfs *fs, struct iatt *iatt, struct stat *stat)
+{
+    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;
+}
+
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_iatt_from_statx, 6.0)
+void
+priv_glfs_iatt_from_statx(struct iatt *iatt, const struct glfs_stat *statx)
+{
+    /* 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;
+}
 
 void
-glfs_iatt_to_stat (struct glfs *fs, struct iatt *iatt, struct stat *stat)
+glfsflags_from_gfapiflags(struct glfs_stat *stat, int *glvalid)
 {
-	iatt_to_stat (iatt, stat);
-	stat->st_dev = fs->dev_id;
-}
+    *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)
+glfs_loc_unlink(loc_t *loc)
 {
-	inode_unlink (loc->inode, loc->parent, loc->name);
+    inode_unlink(loc->inode, loc->parent, loc->name);
 
-	return 0;
-}
+    /* 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)
-{
-	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;
+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;
+    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);
-
-	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 = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
+
+    if (ret)
+        goto out;
 
-	ret = syncop_open (subvol, &loc, flags, glfd->fd, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    if (IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
 
-	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 (fop_attr)
-                dict_unref (fop_attr);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	if (ret && glfd) {
-                GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd_set_state_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_open, 3.4.0);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_close, 3.4.0)
 int
-pub_glfs_close (struct glfs_fd *glfd)
-{
-	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);
+pub_glfs_close(struct glfs_fd *glfd)
+{
+    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)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_flush (subvol, fd, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (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;
-
-        if (fd)
-                fd_unref (fd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    fs = glfd->fs;
 
+    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)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	struct iatt      iatt = {0, };
-	fd_t            *fd = NULL;
+priv_glfs_statx(struct glfs *fs, const char *path, const unsigned int mask,
+                struct glfs_stat *statxbuf)
+{
+    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_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.
-	*/
+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 (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);
+    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_set_state_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);
+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;
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *fop_attr = NULL;
 
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-static ssize_t
-glfs_preadv_common (struct glfs_fd *glfd, const struct iovec *iovec,
-                    int iovcnt, off_t offset, int flags, struct 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;
-        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");
+    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_readv (subvol, fd, size, offset, 0, &iov, &cnt, &iobref,
-                            &iatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    size = iov_length(iovec, iovcnt);
 
-        if (ret >= 0 && poststat)
-                glfs_iatt_to_stat (glfd->fs, &iatt, poststat);
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
 
-	if (ret <= 0)
-		goto out;
+    ret = syncop_readv(subvol, fd, size, offset, 0, &iov, &cnt, &iobref, &iatt,
+                       fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	size = iov_copy (iovec, iovcnt, iov, cnt); /* FIXME!!! */
+    if (ret >= 0 && poststat)
+        glfs_iatt_to_statx(glfd->fs, &iatt, poststat);
 
-	glfd->offset = (offset + size);
+    if (ret <= 0)
+        goto out;
 
-	ret = size;
+    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);
+    if (iov)
+        GF_FREE(iov);
+    if (iobref)
+        iobref_unref(iobref);
 
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    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_preadv, 3.4.0)
 ssize_t
-pub_glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-                 off_t offset, int flags)
+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);
+    return glfs_preadv_common(glfd, iovec, iovcnt, offset, flags, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv, 3.4.0);
-
-
+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)
+pub_glfs_read(struct glfs_fd *glfd, void *buf, size_t count, int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
-
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_preadv (glfd, &iov, 1, glfd->offset, flags);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read, 3.4.0);
+    ret = pub_glfs_preadv(glfd, &iov, 1, glfd->offset, flags);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC(glfs_pread34, glfs_pread, 3.4.0)
 ssize_t
-pub_glfs_pread34 (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
-                  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, offset, flags);
+    ret = pub_glfs_preadv(glfd, &iov, 1, offset, flags);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_pread34, glfs_pread, 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, struct stat *poststat)
+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 = glfs_preadv_common (glfd, &iov, 1, offset, flags, poststat);
+    ret = glfs_preadv_common(glfd, &iov, 1, offset, flags, poststat);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread, future);
-
-
+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;
-	gf_boolean_t         oldcb;
-	union {
-		glfs_io_cbk34      fn34;
-		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,
-                   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;
-        struct stat     prestat = {}, *prestatp = NULL;
-        struct 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;
-                }
-
-                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;
+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;
+    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;
         }
 
-out:
-        errno = op_errno;
-        if (gio->oldcb) {
-                gio->fn34 (gio->glfd, op_ret, gio->data);
-        } else {
-                if (prebuf) {
-                       prestatp = &prestat;
-                       glfs_iatt_to_stat (fs, prebuf, prestatp);
-                }
+        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;
+    }
 
-                if (postbuf) {
-                       poststatp = &poststat;
-                       glfs_iatt_to_stat (fs, postbuf, poststatp);
-                }
-
-                gio->fn (gio->glfd, op_ret, prestatp, poststatp, gio->data);
+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);
         }
-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);
+        if (postbuf) {
+            poststatp = &poststat;
+            glfs_iatt_to_statx(fs, postbuf, poststatp);
+        }
 
-        ret = 0;
+        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;
 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,
-                           NULL, stbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, iovec, count, NULL,
+                      stbuf);
 
-	return 0;
+    return 0;
 }
 
-
 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)
+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;
-	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);
+    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 (fop_attr)
-                dict_unref (fop_attr);
+    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(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)
+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);
+    return glfs_preadv_async_common(glfd, iovec, count, offset, flags, _gf_true,
+                                    (void *)fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_preadv_async34, glfs_preadv_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, 6.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)
+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)
 {
-       return glfs_preadv_async_common (glfd, iovec, count, offset, flags,
-                                        _gf_false, fn, data);
+    return glfs_preadv_async_common(glfd, iovec, count, offset, flags,
+                                    _gf_false, fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, future);
-
-
+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)
+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;
-
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = glfs_preadv_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                        _gf_true, (void *)fn, data);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC(glfs_read_async34, 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_read_async (struct glfs_fd *glfd, void *buf, size_t count, 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;
-
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = glfs_preadv_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                        _gf_false, 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, future);
+    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_pread_async34 (struct glfs_fd *glfd, void *buf, size_t count,
-                        off_t offset, int flags, glfs_io_cbk34 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)
 {
-	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 = glfs_preadv_async_common (glfd, &iov, 1, offset, flags,
-                                        _gf_true, (void *)fn, data);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_true,
+                                   (void *)fn, data);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_pread_async34, glfs_pread_async, 3.4.0);
-
-
+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)
+pub_glfs_pread_async(struct glfs_fd *glfd, void *buf, size_t count,
+                     off_t offset, 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;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-        ret = glfs_preadv_async_common (glfd, &iov, 1, offset, flags,
-                                        _gf_false, fn, data);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn,
+                                   data);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread_async, future);
-
-
+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)
+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;
+    ssize_t ret = 0;
 
-	ret = glfs_preadv_async_common (glfd, iov, count, glfd->offset, flags,
-                                        _gf_true, (void *)fn, data);
-	return ret;
-}
-
-GFAPI_SYMVER_PUBLIC(glfs_readv_async34, glfs_readv_async, 3.4.0);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
+    ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags,
+                                   _gf_true, (void *)fn, data);
+    return ret;
+}
 
+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)
+pub_glfs_readv_async(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                     int flags, glfs_io_cbk fn, void *data)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = glfs_preadv_async_common (glfd, iov, count, glfd->offset, flags,
-                                        _gf_false, fn, data);
-	return ret;
-}
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv_async, future);
+    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 stat *prestat, struct 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;
+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 (fop_attr)
+        dict_unref(fop_attr);
 
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
+    glfs_subvol_done(glfd->fs, subvol);
 
-        ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags,
-                             &preiatt, &postiatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    __GLFS_EXIT_FS;
 
-        if (ret >= 0) {
-                if (prestat)
-                        glfs_iatt_to_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+invalid_fs:
+    return ret;
+}
 
-	if (ret <= 0)
-		goto out;
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_copy_file_range, 6.0)
+ssize_t
+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)
+{
+    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;
 
-	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 (fop_attr)
-                dict_unref (fop_attr);
+    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);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd_in->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0)
 ssize_t
-pub_glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-                  off_t offset, int flags)
+pub_glfs_pwritev(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                 off_t offset, int flags)
 {
-        return glfs_pwritev_common (glfd, iovec, iovcnt, offset, flags,
-                                    NULL, NULL);
+    return glfs_pwritev_common(glfd, iovec, iovcnt, offset, flags, NULL, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write, 3.4.0)
 ssize_t
-pub_glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, 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, glfd->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_write, 3.4.0);
+    ret = pub_glfs_pwritev(glfd, &iov, 1, glfd->offset, flags);
 
+    return ret;
+}
 
+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)
+pub_glfs_writev(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                int flags)
 {
-	ssize_t      ret = 0;
-
-	ret = pub_glfs_pwritev (glfd, iov, count, glfd->offset, flags);
+    ssize_t ret = 0;
 
-	return ret;
-}
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev, 3.4.0);
+    ret = pub_glfs_pwritev(glfd, iov, count, glfd->offset, flags);
 
+    return ret;
+}
 
+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)
+pub_glfs_pwrite34(struct glfs_fd *glfd, const 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 = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_pwritev (glfd, &iov, 1, offset, flags);
+    ret = pub_glfs_pwritev(glfd, &iov, 1, offset, flags);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_pwrite34, glfs_pwrite, 3.4.0);
-
+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 stat *prestat,
-                 struct stat *poststat)
+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;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_pwritev_common (glfd, &iov, 1, offset, flags,
-                                   prestat, poststat);
+    ret = glfs_pwritev_common(glfd, &iov, 1, offset, flags, prestat, poststat);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite, future);
-
-extern glfs_t *pub_glfs_from_glfd (glfs_fd_t *);
-
+extern glfs_t *
+pub_glfs_from_glfd(glfs_fd_t *);
 
 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_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);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 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)
+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;
+    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 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 (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(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)
+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);
+    return glfs_pwritev_async_common(glfd, iovec, count, offset, flags,
+                                     _gf_true, (void *)fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_pwritev_async34, glfs_pwritev_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, 6.0)
 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)
+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)
 {
-        return glfs_pwritev_async_common (glfd, iovec, count, offset, flags,
-                                          _gf_false, fn, data);
+    return glfs_pwritev_async_common(glfd, iovec, count, offset, flags,
+                                     _gf_false, fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, future);
-
-
+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)
+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;
-
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = glfs_pwritev_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                         _gf_true, (void *)fn, data);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC(glfs_write_async34, 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_write_async (struct glfs_fd *glfd, const void *buf, size_t count,
-                      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;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	ret = glfs_pwritev_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                         _gf_false, fn, data);
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	return ret;
-}
-
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write_async, future);
+    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_pwrite_async34 (struct glfs_fd *glfd, const void *buf, int count,
-                         off_t offset, int flags, glfs_io_cbk34 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)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = glfs_pwritev_async_common (glfd, &iov, 1, offset, flags,
-                                         _gf_true, (void *)fn, data);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_true,
+                                    (void *)fn, data);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_pwrite_async34, glfs_pwrite_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_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_pwrite_async(struct glfs_fd *glfd, const void *buf, int count,
+                      off_t offset, 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 = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_pwritev_async_common (glfd, &iov, 1, offset, flags,
-                                         _gf_false, fn, data);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn,
+                                    data);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_async, future);
-
-
+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)
+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;
-
-	ret = glfs_pwritev_async_common (glfd, iov, count, glfd->offset, flags,
-                                         _gf_true, (void *)fn, data);
-	return ret;
-}
+    ssize_t ret = 0;
 
-GFAPI_SYMVER_PUBLIC(glfs_writev_async34, glfs_writev_async, 3.4.0);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
+    ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags,
+                                    _gf_true, (void *)fn, data);
+    return ret;
+}
 
+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)
+pub_glfs_writev_async(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                      int flags, glfs_io_cbk fn, void *data)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = glfs_pwritev_async_common (glfd, iov, count, glfd->offset, flags,
-                                         _gf_false, fn, data);
-	return ret;
-}
-
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev_async, future);
+    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_common (struct glfs_fd *glfd, struct stat *prestat,
-                   struct 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, 0, &preiatt, &postiatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret >= 0) {
-                if (prestat)
-                        glfs_iatt_to_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+glfs_fsync_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, 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);
+    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(glfs_fsync34, glfs_fsync, 3.4.0)
 int
-pub_glfs_fsync34 (struct glfs_fd *glfd)
+pub_glfs_fsync34(struct glfs_fd *glfd)
 {
-	return glfs_fsync_common (glfd, NULL, NULL);
+    return glfs_fsync_common(glfd, NULL, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_fsync34, glfs_fsync, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, 6.0)
 int
-pub_glfs_fsync (struct glfs_fd *glfd, struct stat *prestat,
-                struct stat *poststat)
+pub_glfs_fsync(struct glfs_fd *glfd, struct glfs_stat *prestat,
+               struct glfs_stat *poststat)
 {
-	return glfs_fsync_common (glfd, prestat, poststat);
+    return glfs_fsync_common(glfd, prestat, poststat);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, future);
-
-
 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_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);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 0;
 }
 
 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);
+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);
-        }
+    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;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC(glfs_fsync_async34, glfs_fsync_async, 3.4.0)
 int
-pub_glfs_fsync_async34 (struct glfs_fd *glfd, glfs_io_cbk34 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, _gf_true, (void *)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(glfs_fsync_async34, glfs_fsync_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, 6.0)
 int
-pub_glfs_fsync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fsync_async(struct glfs_fd *glfd, glfs_io_cbk 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, _gf_false, fn, data, 0);
+    ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 0);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, future);
-
-
 static int
-glfs_fdatasync_common (struct glfs_fd *glfd, struct stat *prestat,
-                       struct 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_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+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 (fop_attr)
-                dict_unref (fop_attr);
+    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(glfs_fdatasync34, glfs_fdatasync, 3.4.0)
 int
-pub_glfs_fdatasync34 (struct glfs_fd *glfd)
+pub_glfs_fdatasync34(struct glfs_fd *glfd)
 {
-        return glfs_fdatasync_common (glfd, NULL, NULL);
+    return glfs_fdatasync_common(glfd, NULL, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_fdatasync34, glfs_fdatasync, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, 6.0)
 int
-pub_glfs_fdatasync (struct glfs_fd *glfd, struct stat *prestat,
-                    struct stat *poststat)
+pub_glfs_fdatasync(struct glfs_fd *glfd, struct glfs_stat *prestat,
+                   struct glfs_stat *poststat)
 {
-       return glfs_fdatasync_common (glfd, prestat, poststat);
+    return glfs_fdatasync_common(glfd, prestat, poststat);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, future);
-
-
+GFAPI_SYMVER_PUBLIC(glfs_fdatasync_async34, glfs_fdatasync_async, 3.4.0)
 int
-pub_glfs_fdatasync_async34 (struct glfs_fd *glfd, glfs_io_cbk34 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, _gf_true, (void *)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(glfs_fdatasync_async34, glfs_fdatasync_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, 6.0)
 int
-pub_glfs_fdatasync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fdatasync_async(struct glfs_fd *glfd, glfs_io_cbk 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, _gf_false, fn, data, 1);
+    ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 1);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, future);
-
-
 static int
-glfs_ftruncate_common (struct glfs_fd *glfd, off_t offset,
-                       struct stat *prestat, struct 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_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+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 (fop_attr)
-                dict_unref (fop_attr);
+    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(glfs_ftruncate34, glfs_ftruncate, 3.4.0)
 int
-pub_glfs_ftruncate34 (struct glfs_fd *glfd, off_t offset)
+pub_glfs_ftruncate34(struct glfs_fd *glfd, off_t offset)
 {
-        return glfs_ftruncate_common (glfd, offset, NULL, NULL);
+    return glfs_ftruncate_common(glfd, offset, NULL, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_ftruncate34, glfs_ftruncate, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, 6.0)
 int
-pub_glfs_ftruncate (struct glfs_fd *glfd, off_t offset, struct stat *prestat,
-                    struct stat *poststat)
+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);
+    return glfs_ftruncate_common(glfd, offset, prestat, poststat);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, future);
-
-
+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;
-        }
+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,
-                           prebuf, postbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 0;
 }
 
 static int
-glfs_ftruncate_async_common (struct glfs_fd *glfd, off_t offset,
-                             gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+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;
-        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;
+    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 (fop_attr)
-                dict_unref (fop_attr);
+    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(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)
+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);
+    return glfs_ftruncate_async_common(glfd, offset, _gf_true, (void *)fn,
+                                       data);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_ftruncate_async34, glfs_ftruncate_async, 3.4.0);
-
-
+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)
+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);
+    return glfs_ftruncate_async_common(glfd, offset, _gf_false, fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate_async, future);
-
-
+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_gfuuid (xattr_req, "gfid-req", gfid, true);
-	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_gfuuid (xattr_req, "gfid-req", gfid, true);
-	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_gfuuid (xattr_req, "gfid-req", gfid, true);
-	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;
+    }
 
-        /* TODO: Add leaseid */
-	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
+     *       - Add leaseid */
+
+    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 == 0) {
+        inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name,
+                     newloc.parent, newloc.name, oldloc.inode, &oldiatt);
 
-	/* 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);
-
-	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 (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_set_state_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 == NULL) {
+        errno = EBADF;
+        return;
+    }
 
-	if (fd->offset == offset)
-		return;
+    if (fd->offset == offset)
+        return;
 
-	fd->offset = offset;
-	fd->next = NULL;
+    fd->offset = offset;
+    fd->next = NULL;
 
-	list_for_each_entry_safe (entry, tmp, &fd->entries, list) {
-		if (entry->d_off != offset)
-			continue;
+    list_for_each_entry_safe(entry, tmp, &fd->entries, list)
+    {
+        if (entry->d_off != offset)
+            continue;
 
-		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()
-	*/
+        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()
+    */
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_seekdir, 3.4.0);
-
 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,
-                           preop_stbuf, postop_stbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf,
+                      postop_stbuf);
 
-        return 0;
+    return 0;
 }
 
 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)
+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;
-        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;
+    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(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)
+pub_glfs_discard_async35(struct glfs_fd *glfd, off_t offset, size_t len,
+                         glfs_io_cbk34 fn, void *data)
 {
-        return glfs_discard_async_common (glfd, offset, len, _gf_true,
-                                          (void *)fn, data);
+    return glfs_discard_async_common(glfd, offset, len, _gf_true, (void *)fn,
+                                     data);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_discard_async35, glfs_discard_async, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, 6.0)
 int
-pub_glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_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)
 {
-        return glfs_discard_async_common (glfd, offset, len, _gf_false, fn,
-                                          data);
+    return glfs_discard_async_common(glfd, offset, len, _gf_false, fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, future);
-
-
 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_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);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf,
+                      postop_stbuf);
 
-        return 0;
+    return 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)
+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;
+    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 (fop_attr)
-                dict_unref (fop_attr);
+    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(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)
+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);
+    return glfs_zerofill_async_common(glfd, offset, len, _gf_true, (void *)fn,
+                                      data);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_zerofill_async35, glfs_zerofill_async, 3.5.0);
-
-
+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)
+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);
+    return glfs_zerofill_async_common(glfd, offset, len, _gf_false, fn, data);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill_async, future);
-
-
 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) {
-                        list_for_each_entry (entry, &entries.list, list) {
-                                if (!entry->inode &&
-                                    !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;
+    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;
-                }
+    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);
 
-        /* TODO : Add leaseid */
-	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)
-{
-	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;
-	}
-
-        /* TODO : Add leaseid */
-	ret = syncop_fsetattr (subvol, fd, iatt, valid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+pub_glfs_fsetattr(struct glfs_fd *glfd, struct glfs_stat *stat)
+{
+    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);
-out:
-	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_process(void *value, size_t size, dict_t *xattr, const char *name)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
+    data_t *data = NULL;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    data = dict_get(xattr, (char *)name);
+    if (!data) {
+        errno = ENODATA;
+        ret = -1;
+        goto out;
+    }
 
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
+    ret = data->len;
+    if (!value || !size)
+        goto out;
 
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
+    if (size < ret) {
+        ret = -1;
+        errno = ERANGE;
+        goto out;
+    }
 
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    memcpy(value, data->data, ret);
+out:
+    return ret;
+}
+
+ssize_t
+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;
+    }
 
 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)
-{
-	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);
+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);
 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)
-{
-	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;
-	}
+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;
+    }
 
 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)
-{
-	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);
+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);
 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;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = 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);
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		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;
-	}
+    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);
+    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)
-{
-	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);
+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;
+    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 (fop_attr)
-                dict_unref (fop_attr);
+    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)
-{
-	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);
+pub_glfs_discard(struct glfs_fd *glfd, off_t offset, size_t len)
+{
+    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 (fop_attr)
-                dict_unref (fop_attr);
+    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;
-        dict_t           *fop_attr         = NULL;
+    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);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                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 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 = 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);
+    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 (fop_attr)
-                dict_unref (fop_attr);
+    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 = GLFS_CALLOC (1, PATH_MAX + 1, NULL,
-                                                   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)
-                        GLFS_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;
-        }
+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);
 
-        /* Generate glusterfs flock structure from client flock
-         * structure to be processed by server */
-        gf_flock_from_flock (&gf_flock, flock);
+        if (ret)
+            goto out;
+    }
 
-        /* Keep another copy of flock for split/merge of locks
-         * at client side */
-        gf_flock_from_flock (&saved_flock, flock);
+    ret = get_fop_attr_thrd_key(&xdata);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
 
-        if (glfd->lk_owner.len != 0) {
-                ret = syncopctx_setfslkowner (&glfd->lk_owner);
+    ret = syncop_lk(subvol, fd, cmd, &gf_flock, xdata, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-                if (ret)
-                        goto out;
-        }
+    /* Convert back from gf_flock to flock as expected by application */
+    gf_flock_to_flock(&gf_flock, flock);
 
-        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, 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_msg (THIS->name, GF_LOG_ERROR, 0,
-                                API_MSG_LOCK_INSERT_MERGE_FAILED,
-                                "Lock insertion and splitting/merging failed "
-                                "on gfid %s", uuid_utoa (fd->inode->gfid));
-                        ret = 0;
-                }
+    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;
         }
+    }
 
 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_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;
-                }
+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_msg (THIS->name, GF_LOG_ERROR, 0,
-                                API_MSG_SETTING_LOCK_TYPE_FAILED,
-                                "Setting lock type failed");
-                        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);
+    ret = glfs_lock_common(glfd, cmd, flock, xdata_in);
 out:
-        if (xdata_in)
-                dict_unref (xdata_in);
+    if (xdata_in)
+        dict_unref(xdata_in);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_file_lock, 4.0.0);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0)
 int
-pub_glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock)
+pub_glfs_posix_lock(struct glfs_fd *glfd, int cmd, struct flock *flock)
 {
-        return glfs_lock_common (glfd, cmd, flock, NULL);
+    return glfs_lock_common(glfd, cmd, flock, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0);
-
+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)
+pub_glfs_fd_set_lkowner(struct glfs_fd *glfd, void *data, int len)
 {
-        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);
 
-        if (!GF_REF_GET (glfd)) {
-                goto invalid_fs;
-        }
+    if (!GF_REF_GET(glfd)) {
+        goto invalid_fs;
+    }
 
-        GF_VALIDATE_OR_GOTO (THIS->name, data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, data, out);
 
-        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;
-        }
+    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;
+    }
 
-        glfd->lk_owner.len = len;
+    glfd->lk_owner.len = len;
 
-        memcpy (glfd->lk_owner.data, data, len);
+    memcpy(glfd->lk_owner.data, data, len);
 
-        ret = 0;
+    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;
-	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;
+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)
+glfs_enqueue_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
 {
-        int ret = -1;
-        upcall_entry *u_list = NULL;
+    int ret = -1;
+    upcall_entry *u_list = NULL;
 
-        if (!fs || !upcall_data)
-                goto out;
+    if (!fs || !upcall_data)
+        goto out;
 
-        u_list = GF_CALLOC (1, sizeof(*u_list),
-                            glfs_mt_upcall_entry_t);
+    u_list = GF_CALLOC(1, sizeof(*u_list), glfs_mt_upcall_entry_t);
 
-        if (!u_list) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    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);
+    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;
+    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) {
+    switch (upcall_data->event_type) {
         case GF_UPCALL_CACHE_INVALIDATION:
-                ret = glfs_get_upcall_cache_invalidation (&u_list->upcall_data,
-                                                          upcall_data);
-                break;
+            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;
+            ret = glfs_get_upcall_lease(&u_list->upcall_data, upcall_data);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall entry validation failed.");
-                goto out;
-        }
+    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);
+    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;
+    ret = 0;
 
 out:
-        if (ret && u_list) {
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE(u_list);
-        }
+    if (ret && u_list) {
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    }
 }
 
 static void
-glfs_free_upcall_lease (void *to_free)
+glfs_free_upcall_lease(void *to_free)
 {
-        struct glfs_upcall_lease *arg = to_free;
+    struct glfs_upcall_lease *arg = to_free;
 
-        if (!arg)
-                return;
+    if (!arg)
+        return;
 
-        if (arg->object)
-                glfs_h_close (arg->object);
+    if (arg->object)
+        glfs_h_close(arg->object);
 
-        GF_FREE (arg);
+    GF_FREE(arg);
 }
 
 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);
-
-        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_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INODE_FIND_FAILED,
-                        "Unable to find inode entry for gfid:%s graph id:%d",
-                        uuid_utoa(up_data->gfid), subvol->graph->id);
-                goto out;
+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)
+        {
+            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);
 
-        LOCK (&inode->lock);
+    if (!list_empty(&glfd_list)) {
+        list_for_each_entry_safe(glfd, tmp, &glfd_list, list)
         {
-                list_for_each_entry (fd, &inode->fd_list, inode_list) {
-                        ret = fd_ctx_get (fd, subvol, &value);
-                        glfd = (struct glfs_fd *) 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);
-                        }
+            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 (&inode->lock);
-
-        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);
+            }
+            UNLOCK(&glfd->lock);
 
-                list_del_init (&glfd->list);
-                GF_REF_PUT (glfd);
+            list_del_init(&glfd->list);
+            GF_REF_PUT(glfd);
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-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;
+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_VALIDATE_OR_GOTO ("gfapi", up_data, out);
-        GF_VALIDATE_OR_GOTO ("gfapi", fs, out);
+    up_lease_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_lease),
+                             glfs_mt_upcall_inode_t);
+    up_lease_arg->object = object;
 
-        recall_lease = up_data->data;
-        GF_VALIDATE_OR_GOTO ("gfapi", recall_lease, out);
+    GF_VALIDATE_OR_GOTO("glfs_recall_lease", up_lease_arg, out);
 
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    up_lease_arg->lease_type = recall_lease->lease_type;
 
-        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_msg (THIS->name, GF_LOG_DEBUG, errno,
-                        API_MSG_CREATE_HANDLE_FAILED,
-                        "handle creation of %s failed",
-                         uuid_utoa (up_data->gfid));
-                errno = ESTALE;
-                goto out;
-        }
+    up_arg->reason = GLFS_UPCALL_RECALL_LEASE;
+    up_arg->event = up_lease_arg;
+    up_arg->free_event = glfs_free_upcall_lease;
 
-        up_lease_arg = GF_CALLOC (1, sizeof (struct glfs_upcall_lease),
-                                  glfs_mt_upcall_inode_t);
-        up_lease_arg->object = object;
+    ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("glfs_recall_lease",
-                             up_lease_arg, out);
+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:
+                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;
+        }
+        if (dict)
+            dict_unref(dict);
+
+        GF_FREE(upcall_data->client_uid);
+        GF_FREE(upcall_data->data);
+    }
+    GF_FREE(args);
+    return 0;
+}
+
+static int
+glfs_upcall_syncop_cbk(int ret, call_frame_t *frame, void *opaque)
+{
+    struct upcall_syncop_args *args = opaque;
 
-        up_lease_arg->lease_type = recall_lease->lease_type;
+    (void)upcall_syncop_args_free(args);
 
-        up_arg->reason = GF_UPCALL_RECALL_LEASE;
-        up_arg->event = up_lease_arg;
-        up_arg->free_event = glfs_free_upcall_lease;
+    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) {
-                /* Close p_object and oldp_object as well if being referenced.*/
-                if (object)
-                        glfs_h_close (object);
+    return ret;
+}
 
-                /* Set reason to prevent applications from using ->event */
-                up_arg->reason = GF_UPCALL_EVENT_NULL;
-        }
-        return ret;
+static struct gf_upcall_cache_invalidation *
+gf_copy_cache_invalidation(struct gf_upcall_cache_invalidation *src)
+{
+    struct gf_upcall_cache_invalidation *dst = NULL;
+
+    if (!src)
+        goto out;
+
+    dst = GF_CALLOC(1, sizeof(struct gf_upcall_cache_invalidation),
+                    glfs_mt_upcall_entry_t);
+
+    if (!dst) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
+
+    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;
+
+    if (src->dict)
+        dst->dict = dict_copy_with_ref(src->dict, NULL);
+
+    return dst;
+out:
+    return NULL;
 }
 
-static void
-glfs_cbk_upcall_data (struct glfs *fs, struct gf_upcall *upcall_data)
+static struct gf_upcall_recall_lease *
+gf_copy_recall_lease(struct gf_upcall_recall_lease *src)
 {
-        int ret = -1;
-        struct glfs_upcall *up_arg = NULL;
+    struct gf_upcall_recall_lease *dst = NULL;
 
-        if (!fs || !upcall_data)
-                goto out;
+    if (!src)
+        goto out;
 
-        if (!(fs->upcall_events & upcall_data->event_type)) {
-                /* ignore events which application hasn't registered*/
-                goto out;
-        }
+    dst = GF_CALLOC(1, sizeof(struct gf_upcall_recall_lease),
+                    glfs_mt_upcall_entry_t);
 
-        up_arg = GLFS_CALLOC (1, sizeof (struct gf_upcall),
-                              glfs_release_upcall,
-                              glfs_mt_upcall_entry_t);
-        if (!up_arg) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    if (!dst) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
 
-        switch (upcall_data->event_type) {
+    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:
-                ret = glfs_h_poll_cache_invalidation (fs, up_arg, upcall_data);
-                break;
+            t_data->data = gf_copy_cache_invalidation(
+                (struct gf_upcall_cache_invalidation *)upcall_data->data);
+            break;
         case GF_UPCALL_RECALL_LEASE:
-                ret = glfs_recall_lease_upcall (fs, up_arg, upcall_data);
-                break;
-        default:
-                errno = EINVAL;
-        }
-
-        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. In such cases up_arg->reason
-                 * is set to GLFS_UPCALL_EVENT_NULL. No need to
-                 * send upcall then */
-                (fs->up_cbk) (up_arg, fs->up_data);
-        } else if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) {
-                gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall_EVENT_NULL received. Skipping it.");
-                goto out;
-        } else {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall entry validation failed.");
-                goto out;
-        }
+            t_data->data = gf_copy_recall_lease(
+                (struct gf_upcall_recall_lease *)upcall_data->data);
+            break;
+    }
 
-        /* application takes care of calling glfs_free on up_arg post
-         * their processing */
-        ret = 0;
+    if (!t_data->data)
+        goto out;
 
+    return args;
 out:
-        if (ret && up_arg) {
-                GLFS_FREE (up_arg);
+    if (ret) {
+        if (args) {
+            GF_FREE(args->upcall_data.client_uid);
+            GF_FREE(args);
         }
+    }
 
-        return;
+    return NULL;
+}
+
+static void
+glfs_cbk_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
+{
+    struct upcall_syncop_args *args = NULL;
+    int ret = -1;
+
+    if (!fs || !upcall_data)
+        goto out;
+
+    if (!(fs->upcall_events & upcall_data->event_type)) {
+        /* ignore events which application hasn't registered*/
+        goto out;
+    }
+
+    args = upcall_syncop_args_init(fs, upcall_data);
+
+    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;
 }
 
 /*
@@ -5307,506 +5943,503 @@ out:
  * 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)
+priv_glfs_process_upcall_event(struct glfs *fs, void *data)
 {
-        glusterfs_ctx_t    *ctx            = NULL;
-        struct gf_upcall   *upcall_data    = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    struct gf_upcall *upcall_data = NULL;
 
-        DECLARE_OLD_THIS;
+    DECLARE_OLD_THIS;
 
-        gf_msg_debug (THIS->name, 0,
-                      "Upcall gfapi callback is called");
+    gf_msg_debug(THIS->name, 0, "Upcall gfapi callback is called");
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, err);
-
-        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);
+    __GLFS_ENTRY_VALIDATE_FS(fs, err);
 
-        upcall_data = (struct gf_upcall *)data;
+    if (!data)
+        goto out;
 
-        gf_msg_trace (THIS->name, 0, "Upcall gfapi gfid = %s" ,
-                      (char *)(upcall_data->gfid));
+    /* 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;
 
-        /* *
-         * 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);
+        /* if we're not interested in upcalls (anymore), skip them */
+        if (ctx->cleanup_started || !fs->cache_upcalls) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto out;
         }
 
-        pthread_mutex_lock (&fs->mutex);
-        {
-                fs->pin_refcnt--;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+        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;
+    __GLFS_EXIT_FS;
 err:
-        return;
+    return;
 }
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_process_upcall_event, 3.7.0);
 
 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;
-        }
-
-        /* 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_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-                        "Allocating anonymous fd failed");
-                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;
+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;
 
 out:
 
-        if (fd)
-                fd_unref(fd);
+    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;
 }
 
 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_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-                        "Allocating anonymous fd failed");
-                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;
+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)
+static void
+glfs_release_xreaddirp_stat(void *ptr)
 {
-        struct glfs_xreaddirp_stat *to_free = ptr;
+    struct glfs_xreaddirp_stat *to_free = ptr;
 
-        if (to_free->object)
-                glfs_h_close (to_free->object);
+    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;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        GF_VALIDATE_OR_GOTO (THIS->name, xstat_p, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, res, out);
-
-        errno = 0;
+    int ret = -1;
+    gf_dirent_t *entry = NULL;
+    struct dirent *buf = NULL;
+    struct glfs_xreaddirp_stat *xstat = NULL;
 
-        if (ext)
-                buf = ext;
-        else
-                buf = glfs_readdirbuf_get (glfd);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        if (!buf)
-                goto out;
+    GF_REF_GET(glfd);
 
-        xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat),
-                            glfs_release_xreaddirp_stat,
-                            glfs_mt_xreaddirp_stat_t);
+    GF_VALIDATE_OR_GOTO(THIS->name, xstat_p, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, res, out);
 
-        if (!xstat)
-                goto out;
+    errno = 0;
 
-        /* this is readdirplus operation */
-        entry = glfd_entry_next (glfd, 1);
+    if (ext)
+        buf = ext;
+    else
+        buf = glfs_readdirbuf_get(glfd);
 
-        /* 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 (!buf)
+        goto out;
 
-        if (!entry) {
-                /* reached EOD, ret = 0  */
-                ret = 0;
-                *res = NULL;
-                *xstat_p = NULL;
+    xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat),
+                        glfs_release_xreaddirp_stat, glfs_mt_xreaddirp_stat_t);
 
-                /* free xstat as applications shall not be using it */
-                GLFS_FREE (xstat);
+    if (!xstat)
+        goto out;
 
-                goto out;
-        }
+    /* this is readdirplus operation */
+    entry = glfd_entry_next(glfd, 1);
 
-        *res = buf;
-        gf_dirent_to_dirent (entry, buf);
+    /* 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 (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;
-                }
+    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;
         }
+    }
 
-        ret = xstat->flags_handled;
-        *xstat_p = xstat;
+    ret = xstat->flags_handled;
+    *xstat_p = xstat;
 
-        gf_msg_debug (THIS->name, 0,
-                      "xreaddirp- requested_flags (%x) , processed_flags (%x)",
-                      flags, xstat->flags_handled);
+    gf_msg_debug(THIS->name, 0,
+                 "xreaddirp- requested_flags (%x) , processed_flags (%x)",
+                 flags, xstat->flags_handled);
 
 out:
-        GF_REF_PUT (glfd);
+    GF_REF_PUT(glfd);
 
-        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));
+    if (ret < 0) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, errno, API_MSG_XREADDIRP_R_FAILED,
+                "reason=%s", strerror(errno), NULL);
 
-                if (xstat)
-                        GLFS_FREE (xstat);
-        }
+        if (xstat)
+            GLFS_FREE(xstat);
+    }
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        return ret;
+    return ret;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
-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_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);
+    GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_stat", xstat, out);
 
-        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;
+    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;
 
 out:
-        return NULL;
+    return NULL;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_stat, 3.11.0);
 
 void
-gf_lease_to_glfs_lease (struct gf_lease *gf_lease, struct glfs_lease *lease)
+gf_lease_to_glfs_lease(struct gf_lease *gf_lease, struct glfs_lease *lease)
 {
-        lease->cmd = gf_lease->cmd;
-        lease->lease_type = gf_lease->lease_type;
-        memcpy (lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE);
+    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);
 }
 
 void
-glfs_lease_to_gf_lease (struct glfs_lease *lease, struct gf_lease *gf_lease)
+glfs_lease_to_gf_lease(struct glfs_lease *lease, struct gf_lease *gf_lease)
 {
-        gf_lease->cmd = lease->cmd;
-        gf_lease->lease_type = lease->lease_type;
-        memcpy (gf_lease->lease_id, lease->lease_id, LEASE_ID_SIZE);
+    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_lease, 4.0.0)
 int
-pub_glfs_lease (struct glfs_fd *glfd, struct glfs_lease *lease,
-                glfs_recall_cbk fn, void *data)
-{
-        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)) {
+pub_glfs_lease(struct glfs_fd *glfd, struct glfs_lease *lease,
+               glfs_recall_cbk fn, void *data)
+{
+    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;
-        }
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
+            }
+            break;
+        case GLFS_RW_LEASE:
+            if (!((fd->flags & O_WRONLY) || (fd->flags & O_RDWR))) {
                 ret = -1;
-                errno = EIO;
+                errno = EINVAL;
                 goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
+            }
+            break;
+        default:
+            if (lease->cmd != GLFS_GET_LEASE) {
                 ret = -1;
-                errno = EBADFD;
+                errno = EINVAL;
                 goto out;
-        }
+            }
+            break;
+    }
 
-        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);
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (fd->inode, loc, out);
+    glfs_lease_to_gf_lease(lease, &gf_lease);
 
-        glfs_lease_to_gf_lease (lease, &gf_lease);
+    ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        ret = syncop_lease (subvol, &loc, &gf_lease, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    gf_lease_to_glfs_lease(&gf_lease, lease);
 
-        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_msg (subvol->name, GF_LOG_ERROR, ENOMEM, API_MSG_FDCTX_SET_FAILED,
-                                           "Setting fd ctx failed for fd(%p)", glfd->fd);
-                           goto out;
-                   }
-                   glfd->cbk = fn;
-                   glfd->cookie = data;
+    /* 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:
 
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        if (subvol)
-                glfs_subvol_done (glfd->fs, subvol);
+    if (subvol)
+        glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
-
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lease, 4.0.0);
diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c
index e40adf04d3d..53c2ee896f9 100644
--- a/api/src/glfs-handleops.c
+++ b/api/src/glfs-handleops.c
@@ -8,2015 +8,2151 @@
  *  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, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL || statvfs == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    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;
+    }
 
-        __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;
+    }
 
-        /* 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, };
-        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");
+    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;
 
-        ret = syncop_open (subvol, &loc, flags, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+out:
+    loc_wipe(&loc);
 
-        glfd->fd->flags = flags;
+    if (inode)
+        inode_unref(inode);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-out:
-        loc_wipe (&loc);
-
-        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_set_state_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_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_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;
+    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;
-        }
-
-        /* 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;
-        }
+    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;
 
-        gf_uuid_generate (gfid);
-        ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-        /* fop/op */
-        ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+        ret = glfs_create_object(&loc, &object);
+    }
 
-        /* populate out args */
-        if ( ret == 0 )  {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
+out:
+    if (ret && object != NULL) {
+        /* Release the held reference */
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+    loc_wipe(&loc);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+    if (inode)
+        inode_unref(inode);
 
-out:
-        if (ret && object != NULL) {
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        loc_wipe(&loc);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        if (inode)
-                inode_unref (inode);
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+        *out_fd = glfd;
+    }
 
-        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_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_gfuuid (xattr_req, "gfid-req", gfid, true);
-        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;
-        }
-
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    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);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (ret && glfd) {
-                GF_REF_PUT (glfd);
-                glfd = NULL;
-        } else if (glfd) {
-                glfd_set_state_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;
-        gf_boolean_t        lookup_needed = _gf_false;
-
-        /* 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);
-
-        /* 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;
-
-                lookup_needed = inode_needs_lookup (newinode, THIS);
-                if (lookup_needed) {
-                        loc.inode = newinode;
-                } else {
-                        /* 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;
-                }
-        }
+    memcpy(loc.gfid, handle, GFAPI_HANDLE_LENGTH);
 
-        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;
-        }
+    /* 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_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;
-        }
+    newinode = inode_find(subvol->itable, loc.gfid);
+    if (newinode) {
+        if (!stat) /* No need of lookup */
+            goto found;
 
-        /* populate stat */
-        if (stat)
-                glfs_iatt_to_stat (fs, &iatt, stat);
+        lookup_needed = inode_needs_lookup(newinode, THIS);
+        if (lookup_needed) {
+            loc.inode = newinode;
+        } else {
+            /* 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;
+    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;
+    }
 
-        DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* validate in args */
-        if (object == 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;
-        }
+    GLFS_LOC_FILL_INODE(inode, loc, 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);
-
-        /* 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_gfuuid (xattr_req, "gfid-req", gfid, true);
-        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 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_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;
-
-        up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE;
-        up_arg->event = up_inode_arg;
-        up_arg->free_event = glfs_free_upcall_inode;
-
-        ret = 0;
+    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;
 
 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 (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;
 }
 
-void glfs_release_upcall (void *ptr)
+void
+glfs_release_upcall(void *ptr)
 {
-        struct glfs_upcall *to_free = ptr;
+    struct glfs_upcall *to_free = ptr;
 
-        if (to_free->event)
-                to_free->free_event (to_free->event);
+    if (to_free->event)
+        to_free->free_event(to_free->event);
 }
 
 /*
@@ -2039,128 +2175,124 @@ void glfs_release_upcall (void *ptr)
  * 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 = 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 */
-                        }
-
-                        /* 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;
-
-                                GLFS_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 intimate knowledge of the
@@ -2174,353 +2306,350 @@ static gf_boolean_t log_upcall370 = _gf_true; /* log once */
  *
  * 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;
+
+    ret = glfs_h_getxattrs_common(fs, new_object, &xattr, acl_key, _gf_false);
+    if (ret)
+        goto out;
 
-        acl = acl_from_text (acl_s);
+    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_xreaddirplus_get_object, 3.11.0);
 
+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)
+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;
-        }
+    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);
+    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);
 
-        glfs_lease_to_gf_lease (lease, &gf_lease);
+    glfs_lease_to_gf_lease(lease, &gf_lease);
 
-        ret = syncop_lease (subvol, &loc, &gf_lease, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        gf_lease_to_glfs_lease (&gf_lease, lease);
+    gf_lease_to_glfs_lease(&gf_lease, lease);
 
 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_lease, 4.0.0);
diff --git a/api/src/glfs-handles.h b/api/src/glfs-handles.h
index 4b336909b57..4d039b9c76b 100644
--- a/api/src/glfs-handles.h
+++ b/api/src/glfs-handles.h
@@ -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 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
-
 /* 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
@@ -113,159 +105,156 @@ typedef struct glfs_object glfs_object_t;
 struct glfs_upcall_inode;
 typedef struct glfs_upcall_inode glfs_upcall_inode_t;
 
-glfs_object_t*
-glfs_upcall_inode_get_object (glfs_upcall_inode_t *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 (glfs_upcall_inode_t *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 (glfs_upcall_inode_t *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 (glfs_upcall_inode_t *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_expire, 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);
+glfs_upcall_inode_get_expire(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_expire, 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);
+glfs_object_t *
+glfs_upcall_inode_get_pobject(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_pobject, 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_pstat(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_pstat, 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);
+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 */
-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);
+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 (glfs_t *fs, glfs_object_t *parent, const char *path) __THROW
-        GFAPI_PUBLIC(glfs_h_unlink, 3.4.2);
+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 (glfs_object_t *object) __THROW
-        GFAPI_PUBLIC(glfs_h_close, 3.4.2);
+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);
+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 (glfs_t *fs, glfs_object_t *object,
-                 off_t offset) __THROW
-        GFAPI_PUBLIC(glfs_h_truncate, 3.4.2);
+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(glfs_t *fs, glfs_object_t *object, struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_stat, 3.4.2);
+    GFAPI_PUBLIC(glfs_h_stat, 3.4.2);
 
 int
 glfs_h_statfs(glfs_t *fs, glfs_object_t *object, struct statvfs *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_statfs, 3.7.0);
+    GFAPI_PUBLIC(glfs_h_statfs, 3.7.0);
 
 int
-glfs_h_getattrs (glfs_t *fs, glfs_object_t *object, struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_getattrs, 3.4.2);
+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 (glfs_t *fs, glfs_object_t *object, const char *name,
-                  void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_h_getxattrs, 3.5.1);
+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 (glfs_t *fs, glfs_object_t *object, struct stat *sb,
-                 int valid) __THROW
-        GFAPI_PUBLIC(glfs_h_setattrs, 3.4.2);
+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 (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);
+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 (glfs_t *fs, glfs_object_t *object, char *buf,
-                 size_t bufsiz) __THROW
-        GFAPI_PUBLIC(glfs_h_readlink, 3.4.2);
+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 (glfs_t *fs, glfs_object_t *linktgt, glfs_object_t *parent,
-             const char *name) __THROW
-        GFAPI_PUBLIC(glfs_h_link, 3.4.2);
+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 (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);
+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 (glfs_t *fs, glfs_object_t *object,
-                     const char *name) __THROW
-        GFAPI_PUBLIC(glfs_h_removexattrs, 3.5.1);
+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 (glfs_object_t *object, unsigned char *handle,
-                       int len) __THROW
-        GFAPI_PUBLIC(glfs_h_extract_handle, 3.4.2);
+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
  */
-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);
+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 */
-glfs_fd_t*
-glfs_h_opendir (glfs_t *fs, glfs_object_t *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);
 
-glfs_fd_t*
-glfs_h_open (glfs_t *fs, glfs_object_t *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 (glfs_t *fs, glfs_object_t *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
 
@@ -297,53 +286,70 @@ glfs_h_access (glfs_t *fs, glfs_object_t *object, int mask) __THROW
 */
 
 int
-glfs_h_poll_upcall (glfs_t *fs, glfs_upcall_t **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 (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);
+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 (glfs_t *fs, glfs_object_t *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 (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);
+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 (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);
+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.
  */
-glfs_object_t*
-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()'
  */
-glfs_object_t*
-glfs_object_copy (glfs_object_t *src) __THROW
-        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_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);
 
-glfs_object_t*
-glfs_h_find_handle (glfs_t *fs, unsigned char *handle,
-                    int len) __THROW
-        GFAPI_PUBLIC(glfs_h_lease, 4.0.0);
 __END_DECLS
 
 #endif /* !_GLFS_HANDLES_H */
diff --git a/api/src/glfs-internal.h b/api/src/glfs-internal.h
index 52048f4592d..7cc3b18a104 100644
--- a/api/src/glfs-internal.h
+++ b/api/src/glfs-internal.h
@@ -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,362 +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(fn1, fn2, ver)                                    \
+    __attribute__((__symver__(STR(fn2) "@GFAPI_PRIVATE_" STR(ver))))
 
-#define GFAPI_SYMVER_PRIVATE_DEFAULT(fn, ver) \
-        asm(".symver priv_"STR(fn)", "STR(fn)"@@GFAPI_PRIVATE_"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_PUBLIC(fn1, fn2, ver) \
-        asm(".symver pub_"STR(fn1)", "STR(fn2)"@GFAPI_"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))
+#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 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 */
+    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;
-        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;
+    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_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 */
+    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 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
+#define GF_MEMPOOL_COUNT_OF_LRU_BUF_T 256
 
-typedef void (glfs_mem_release_t) (void *ptr);
+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;
+    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_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)
+__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;
+    struct glfs_mem_header *header = NULL;
 
-        header = __gf_calloc(nmemb, (size + GLFS_MEM_HEADER_SIZE),
-                             type, typestr);
-        if (!header)
-                return 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;
+    header->magic = GLFS_MEM_HEADER_MAGIC;
+    header->nmemb = nmemb;
+    header->size = size;
+    header->release = release;
 
-        return header + 1;
+    return header + 1;
 }
 
 static inline void *
-__glfs_malloc (size_t size, glfs_mem_release_t release,
-               uint32_t type, const char *typestr)
+__glfs_malloc(size_t size, glfs_mem_release_t release, uint32_t type,
+              const char *typestr)
 {
-        struct glfs_mem_header *header = NULL;
+    struct glfs_mem_header *header = NULL;
 
-        header = __gf_malloc((size + GLFS_MEM_HEADER_SIZE), type, typestr);
-        if (!header)
-                return 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;
+    header->magic = GLFS_MEM_HEADER_MAGIC;
+    header->nmemb = 1;
+    header->size = size;
+    header->release = release;
 
-        return header + 1;
+    return header + 1;
 }
 
 static inline void *
-__glfs_realloc (void *ptr, size_t size)
+__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;
+    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);
+    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;
+    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_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;
+    new_header = (struct glfs_mem_header *)new_ptr;
+    *new_header = tmp_header;
+    new_header->size = size;
 
-        return new_header + 1;
+    return new_header + 1;
 }
 
 static inline void
-__glfs_free (void *free_ptr)
+__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;
-                }
+    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);
+    __gf_free(header);
 }
 
-#define GLFS_CALLOC(nmemb, size, release, type) \
-        __glfs_calloc (nmemb, size, release, type, #type)
+#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_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)
+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
@@ -454,62 +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);
-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);
-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
@@ -535,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
@@ -562,35 +633,29 @@ struct glfs *glfs_new_from_ctx (glusterfs_ctx_t *ctx)
 */
 
 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);
+glfs_free_from_ctx(struct glfs *fs) GFAPI_PRIVATE(glfs_free_from_ctx, 3.7.0);
 
 int
-glfs_recall_lease_upcall (struct glfs *fs, struct glfs_upcall *up_arg,
-                          struct gf_upcall *up_data);
+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);
+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_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
@@ -601,52 +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);
+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);
+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);
+glfs_lease_to_gf_lease(struct glfs_lease *lease, struct gf_lease *gf_lease);
 
-void glfs_release_upcall (void *ptr);
+void
+glfs_release_upcall(void *ptr);
 
 int
-get_fop_attr_glfd (dict_t **fop_attr, struct glfs_fd *glfd);
+get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd);
 
 int
-set_fop_attr_glfd (struct glfs_fd *glfd);
+set_fop_attr_glfd(struct glfs_fd *glfd);
 
 int
-get_fop_attr_thrd_key (dict_t **fop_attr);
+get_fop_attr_thrd_key(dict_t **fop_attr);
 
 void
-unset_fop_attr (dict_t **fop_attr);
+unset_fop_attr(dict_t **fop_attr);
+
+/*
+  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_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 9648bbbc03a..100dcc16cc0 100644
--- a/api/src/glfs-master.c
+++ b/api/src/glfs-master.c
@@ -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 7bfa8c98c0f..bfa325a3ad9 100644
--- a/api/src/glfs-mem-types.h
+++ b/api/src/glfs-mem-types.h
@@ -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 fac903b805a..7c82b8cd162 100644
--- a/api/src/glfs-mgmt.c
+++ b/api/src/glfs-mgmt.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -16,1085 +15,1035 @@
 #include <signal.h>
 #include <pthread.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "glfs.h"
-#include "dict.h"
-#include "gf-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));
+
+    ret = glfs_get_volume_info_rpc(frame, THIS, fs);
+    if (ret)
+        goto out;
 
-        __yield ((&args));
+    __yield((&args));
 
-        frame->local = NULL;
-        STACK_DESTROY (frame->root);
+    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 = 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;
-	}
+    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;
-        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_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;
-	}
-
-        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);
-        }
+    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;
-
-	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;
-	}
-
-        /* 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_msg (frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO,
-                        "Unable to delete file: %s", template);
-                ret = 0;
+    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 (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);
         }
+    }
 
-        tmpfp = fdopen (tmp_fd, "w+b");
-        if (!tmpfp) {
-                ret = -1;
-                goto out;
-        }
+    if (tmpfp)
+        fclose(tmpfp);
+    else if (tmp_fd != -1)
+        sys_close(tmp_fd);
 
-	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;
-        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 (dict)
-                dict_unref (dict);
-
-	// 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);
-        else if (tmp_fd != -1)
-                sys_close (tmp_fd);
-
-	return 0;
+    return 0;
 }
 
-
 int
-glfs_volfile_fetch (struct glfs *fs)
+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;
-        }
-
-        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;
-        }
-
-        /* 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_msg (THIS->name, GF_LOG_ERROR, 0,
-                        API_MSG_DICT_SERIALIZE_FAILED,
-                        "Failed to serialize dictionary");
-                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);
+    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;
+                    }
                 }
-                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_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 = 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;
+                }
+                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;
                 }
 
-                break;
-	default:
-		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");
+                }
+
+                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;
-                ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
-
-	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 88e2d8926a0..8a393ecb464 100644
--- a/api/src/glfs-resolve.c
+++ b/api/src/glfs-resolve.c
@@ -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 "gf-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,838 +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, ".", &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"
-        *
-        * 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;
-                        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_gfuuid (xattr_req, "gfid-req", gfid, true);
-                if (ret) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+        xattr_req = dict_new();
+        if (!xattr_req) {
+            errno = ENOMEM;
+            goto out;
+        }
+
+        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);
+        }
 
-	}
-
-	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_gfuuid (xattr_req, "gfid-req", gfid, true);
-		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);
+        inode_unref(loc.inode);
+        gf_uuid_clear(loc.gfid);
+        loc.inode = inode_new(parent->table);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
 
-        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);
+        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);
-
-        if (origpath[0] == '\0') {
-                errno = EINVAL;
-                goto invalid_fs;
+    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;
         }
 
-	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 (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;
+        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, 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
@@ -917,290 +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);
-        /* TODO: Migrate the fds and inodes which have leases to the new graph (issue #350)*/
-
-	/* 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
-         * 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);
-	}
-}
+    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 a249534ffef..b4bf1423f6d 100644
--- a/api/src/glfs.c
+++ b/api/src/glfs.c
@@ -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)
@@ -35,756 +34,739 @@
 #include <sys/prctl.h>
 #endif
 
-#include "glusterfs.h"
-#include "logging.h"
-#include "stack.h"
-#include "gf-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 "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;
+    int ret = 0;
+    xlator_t *master = NULL;
 
-	master = GF_CALLOC (1, sizeof (*master),
-			    glfs_mt_xlator_t);
-	if (!master)
-		goto err;
+    master = GF_CALLOC(1, sizeof(*master), glfs_mt_xlator_t);
+    if (!master)
+        goto err;
 
-	master->name = gf_strdup ("gfapi");
-	if (!master->name)
-		goto err;
+    master->name = gf_strdup("gfapi");
+    if (!master->name)
+        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;
-	}
+    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	 = get_new_dict ();
-	if (!master->options)
-		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_smsg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED,
+                NULL);
+        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;
-	}
+    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);
 
-	ret = glfs_process_volfp (fs, fp);
-	if (ret)
-		goto out;
+    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;
 
 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;
-        int                    ret = -1;
-        char                  *server_host = NULL;
-        char                  *server_transport = NULL;
-
-        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;
-        }
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+    char *server_host = NULL;
+    char *server_transport = NULL;
 
-        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_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);
-                        goto out;
-                }
+    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_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));
+            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));
+    }
 
 out:
-        if (server_host) {
-                GF_FREE (server_host);
-        }
+    if (server_host) {
+        GF_FREE(server_host);
+    }
 
-        if (server_transport) {
-                GF_FREE (server_transport);
-        }
+    if (server_transport) {
+        GF_FREE(server_transport);
+    }
 
-        __GLFS_EXIT_FS;
+    __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()
  */
 static void
-glfs_free_volfile_servers (cmd_args_t *cmd_args)
+glfs_free_volfile_servers(cmd_args_t *cmd_args)
 {
-        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;
+    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;
+    return;
 }
 
 static void
-glfs_free_xlator_options (cmd_args_t *cmd_args)
+glfs_free_xlator_options(cmd_args_t *cmd_args)
 {
-        xlator_cmdline_option_t *xo     = NULL;
-        xlator_cmdline_option_t *tmp_xo = NULL;
-
-        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);
-        }
+    xlator_cmdline_option_t *xo = NULL;
+    xlator_cmdline_option_t *tmp_xo = NULL;
+
+    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)
+pub_glfs_setfsgid(gid_t fsgid)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsgid (&fsgid);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsgid(&fsgid);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgid, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2)
 int
-pub_glfs_setfsgroups (size_t size, const gid_t *list)
+pub_glfs_setfsgroups(size_t size, const gid_t *list)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsgroups(size, list);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsgroups(size, list);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsleaseid, 4.0.0)
 int
-pub_glfs_setfsleaseid (glfs_leaseid_t leaseid)
+pub_glfs_setfsleaseid(glfs_leaseid_t leaseid)
 {
-        int           ret     = -1;
-        char         *gleaseid = NULL;
-
-        GF_VALIDATE_OR_GOTO (THIS->name, leaseid, out);
+    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;
+    }
 
-        gleaseid = gf_leaseid_get();
-        if (gleaseid) {
-                memcpy (gleaseid, leaseid, LEASE_ID_SIZE);
-                ret = 0;
-        }
-out:
-        return ret;
+    if (ret)
+        gf_log("glfs", GF_LOG_ERROR, "failed to set leaseid: %s",
+               strerror(errno));
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsleaseid, 4.0.0);
-
 int
-get_fop_attr_glfd (dict_t **fop_attr, struct glfs_fd *glfd)
+get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd)
 {
-        char *leaseid            = NULL;
-        int   ret                = 0;
-        gf_boolean_t dict_create = _gf_false;
-
-        leaseid = GF_CALLOC (1, 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_static_bin (*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);
+    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;
-                }
+    if (ret) {
+        GF_FREE(leaseid);
+        if (dict_create) {
+            if (*fop_attr)
+                dict_unref(*fop_attr);
+            *fop_attr = NULL;
         }
-        return ret;
+    }
+    return ret;
 }
 
 int
-set_fop_attr_glfd (struct glfs_fd *glfd)
+set_fop_attr_glfd(struct glfs_fd *glfd)
 {
-        char     *lease_id = NULL;
-        int       ret      = -1;
+    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;
+    lease_id = gf_existing_leaseid();
+    if (lease_id) {
+        memcpy(glfd->lease_id, lease_id, LEASE_ID_SIZE);
+        ret = 0;
+    }
+    return ret;
 }
 
 int
-get_fop_attr_thrd_key (dict_t **fop_attr)
+get_fop_attr_thrd_key(dict_t **fop_attr)
 {
-        char     *lease_id       = NULL;
-        int       ret            = 0;
-        gf_boolean_t dict_create = _gf_false;
-
-        lease_id = gf_existing_leaseid ();
-        if (lease_id) {
-                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", gf_strdup (lease_id),
-                                    LEASE_ID_SIZE);
+    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 && dict_create) {
-                if (*fop_attr)
-                        dict_unref (*fop_attr);
-                *fop_attr = NULL;
+    if (ret) {
+        GF_FREE(leaseid);
+        if (dict_create) {
+            if (*fop_attr)
+                dict_unref(*fop_attr);
+            *fop_attr = NULL;
         }
-        return ret;
+    }
+    return ret;
 }
 
 void
-unset_fop_attr (dict_t **fop_attr)
+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;
-        }
+    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)
+pub_glfs_from_glfd(struct glfs_fd *glfd)
 {
-	return glfd->fs;
-}
+    if (glfd == NULL) {
+        errno = EBADF;
+        return NULL;
+    }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_from_glfd, 3.4.0);
+    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->upcall_events = 0;
-        fs->up_cbk = NULL;
-        fs->up_data = NULL;
+    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;
@@ -792,956 +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;
-        char            pname[16]       = "";
-        char            msg[32]         = "";
-
-        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;
-        fs->ctx->process_mode = GF_CLIENT_PROCESS;
+    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;
 
+    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);
+    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;
+    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);
 
-        if (fs->oldvolfile)
-                FREE (fs->oldvolfile);
+    PTHREAD_COND_DESTROY(&fs->child_down_cond, fs->pthread_flags,
+                         GLFS_INIT_COND_CHILD);
 
-        FREE (fs->volname);
+    PTHREAD_MUTEX_DESTROY(&fs->upcall_list_mutex, fs->pthread_flags,
+                          GLFS_INIT_MUTEX_UPCALL);
 
-        FREE (fs);
-}
+    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;
+    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);
 
-        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 (fs->ctx, 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:
-        __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;
+    }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_init_done, 3.4.0);
+    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;
+}
 
 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);
-
-        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 = 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);
-        }
-
-        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);
-                rpc_clnt_unref (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);
-        }
-
-        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;
+            }
+
+            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;
+            }
         }
-
-        /* 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);
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_setfspid, 6.1)
+int
+priv_glfs_setfspid(struct glfs *fs, pid_t pid)
+{
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
+
+    cmd_args = &fs->ctx->cmd_args;
+    cmd_args->client_pid = pid;
+    cmd_args->client_pid_set = 1;
+    ret = syncopctx_setfspid(&pid);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_free, 3.7.16)
 void
-pub_glfs_free (void *ptr)
+pub_glfs_free(void *ptr)
 {
-        GLFS_FREE (ptr);
+    GLFS_FREE(ptr);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_free, 3.7.16);
-
-
-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);
-
 
-/*struct glfs_object*
-pub_glfs_upcall_lease_get_object (struct glfs_upcall_recall_inode *arg)
+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;
+    return arg->object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_object, 4.0.0);
-*/
-
+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)
+pub_glfs_upcall_lease_get_lease_type(struct glfs_upcall_lease *arg)
 {
-        return arg->lease_type;
+    return arg->lease_type;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_lease_type, 4.0.0);
 
 /* 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;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_sysrq, 3.10.0);
-
+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)
+pub_glfs_upcall_register(struct glfs *fs, uint32_t event_list,
+                         glfs_upcall_cbk cbk, void *data)
 {
-        int ret = 0;
+    int ret = 0;
 
-        /* list of supported upcall events */
-        uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE;
+    /* 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);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, cbk, out);
+    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_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-                        "invalid event_list (0x%08x)", event_list);
-                goto 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;
         }
-
-        /* 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 |= GF_UPCALL_CACHE_INVALIDATION;
-                } else if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
-                        fs->upcall_events |=  GF_UPCALL_RECALL_LEASE;
-                        ret |= GF_UPCALL_RECALL_LEASE;
-                }
-                /* Override cbk function if existing */
-                fs->up_cbk = cbk;
-                fs->up_data = data;
-                fs->cache_upcalls = _gf_true;
+        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;
         }
-        pthread_mutex_unlock (&fs->mutex);
+        /* Override cbk function if existing */
+        fs->up_cbk = cbk;
+        fs->up_data = data;
+        fs->cache_upcalls = _gf_true;
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_register, 3.13.0);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_unregister, 3.13.0)
 int
-pub_glfs_upcall_unregister (struct glfs *fs, uint32_t event_list)
+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;
+    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);
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+out:
+    __GLFS_EXIT_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_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-                        "invalid event_list (0x%08x)", event_list);
-                goto out;
+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;
         }
+    }
 
-        pthread_mutex_lock (&fs->mutex);
-        {
-                if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
-                        fs->upcall_events &=  ~GF_UPCALL_CACHE_INVALIDATION;
-                        ret |= GF_UPCALL_CACHE_INVALIDATION;
-                }
+    /* If set, it needs to be freed, so we don't have leak */
+    GF_FREE(fs->ctx->statedump_path);
 
-                /* 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);
+    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;
+    }
 
-out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
+
+    return 0;
+err:
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return -1;
 }
-
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_unregister, 3.13.0);
diff --git a/api/src/glfs.h b/api/src/glfs.h
index 3681cd11450..279d11d58ee 100644
--- a/api/src/glfs.h
+++ b/api/src/glfs.h
@@ -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
@@ -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
@@ -188,14 +231,14 @@ 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);
+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);
+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
 
@@ -226,8 +269,8 @@ 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);
+glfs_set_logging(glfs_t *fs, const char *logfile, int loglevel) __THROW
+    GFAPI_PUBLIC(glfs_set_logging, 3.4.0);
 
 /*
   SYNOPSIS
@@ -254,9 +297,7 @@ 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);
-
+glfs_init(glfs_t *fs) __THROW GFAPI_PUBLIC(glfs_init, 3.4.0);
 
 /*
   SYNOPSIS
@@ -289,8 +330,7 @@ glfs_init (glfs_t *fs) __THROW
 */
 
 int
-glfs_fini (glfs_t *fs) __THROW
-        GFAPI_PUBLIC(glfs_fini, 3.4.0);
+glfs_fini(glfs_t *fs) __THROW GFAPI_PUBLIC(glfs_fini, 3.4.0);
 
 /*
   SYNOPSIS
@@ -321,9 +361,8 @@ glfs_fini (glfs_t *fs) __THROW
 */
 
 ssize_t
-glfs_get_volfile (glfs_t *fs, void *buf, size_t len) __THROW
-        GFAPI_PUBLIC(glfs_get_volfile, 3.6.0);
-
+glfs_get_volfile(glfs_t *fs, void *buf, size_t len) __THROW
+    GFAPI_PUBLIC(glfs_get_volfile, 3.6.0);
 
 /*
   SYNOPSIS
@@ -337,8 +376,8 @@ glfs_get_volfile (glfs_t *fs, void *buf, size_t len) __THROW
        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
        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.
+       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
 
@@ -354,9 +393,8 @@ glfs_get_volfile (glfs_t *fs, void *buf, size_t len) __THROW
 */
 
 int
-glfs_get_volumeid (glfs_t *fs, char *volid, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_get_volumeid, 3.5.0);
-
+glfs_get_volumeid(glfs_t *fs, char *volid, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_get_volumeid, 3.5.0);
 
 /*
  * FILE OPERATION
@@ -377,6 +415,116 @@ glfs_get_volumeid (glfs_t *fs, char *volid, size_t size) __THROW
 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];
 
@@ -406,20 +554,18 @@ typedef char glfs_leaseid_t[GLFS_LEASE_ID_SIZE];
  *
  */
 int
-glfs_setfsuid (uid_t fsuid) __THROW
-        GFAPI_PUBLIC(glfs_setfsuid, 3.4.2);
+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);
+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);
+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);
+glfs_setfsleaseid(glfs_leaseid_t leaseid) __THROW
+    GFAPI_PUBLIC(glfs_setfsleaseid, 4.0.0);
 
 /*
   SYNOPSIS
@@ -446,9 +592,9 @@ glfs_setfsleaseid (glfs_leaseid_t leaseid) __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
@@ -476,22 +622,20 @@ 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);
+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);
+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);
 
 /*
 
@@ -514,183 +658,190 @@ 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, struct stat *prestat,
-                             struct stat *poststat, 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);
+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);
+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, future);
+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, future);
+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);
+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);
+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, future);
+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, future);
+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,
-            struct stat *poststat) __THROW
-        GFAPI_PUBLIC(glfs_pread, future);
+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 stat *prestat, struct stat *poststat) __THROW
-        GFAPI_PUBLIC(glfs_pwrite, future);
+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, future);
+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, future);
+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);
+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);
+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, future);
+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, future);
+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);
+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);
+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 stat *prestat,
-                struct stat *poststat) __THROW
-        GFAPI_PUBLIC(glfs_ftruncate, future);
+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, future);
+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);
+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);
+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);
+glfs_fstat(glfs_fd_t *fd, struct stat *buf) __THROW
+    GFAPI_PUBLIC(glfs_fstat, 3.4.0);
 
 int
-glfs_fsync (glfs_fd_t *fd, struct stat *prestat, struct stat *poststat) __THROW
-        GFAPI_PUBLIC(glfs_fsync, future);
+glfs_fsync(glfs_fd_t *fd, struct glfs_stat *prestat,
+           struct glfs_stat *poststat) __THROW GFAPI_PUBLIC(glfs_fsync, 6.0);
 
 int
-glfs_fsync_async (glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_fsync_async, future);
+glfs_fsync_async(glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_fsync_async, 6.0);
 
 int
-glfs_fdatasync (glfs_fd_t *fd, struct stat *prestat,
-                struct stat *poststat) __THROW
-        GFAPI_PUBLIC(glfs_fdatasync, future);
+glfs_fdatasync(glfs_fd_t *fd, struct glfs_stat *prestat,
+               struct glfs_stat *poststat) __THROW
+    GFAPI_PUBLIC(glfs_fdatasync, 6.0);
 
 int
-glfs_fdatasync_async (glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_fdatasync_async, future);
+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);
+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);
+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);
+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);
+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);
+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);
+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);
+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);
+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);
+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,
@@ -701,14 +852,14 @@ glfs_opendir (glfs_t *fs, const char *path) __THROW
  */
 
 int
-glfs_readdir_r (glfs_fd_t *fd, struct dirent *dirent,
-                struct dirent **result) __THROW
-        GFAPI_PUBLIC(glfs_readdir_r, 3.4.0);
+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);
+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
@@ -717,162 +868,152 @@ 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_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_readdirplus(glfs_fd_t *fd, struct stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_readdirplus, 3.5.0);
 
 long
-glfs_telldir (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_telldir, 3.4.0);
+glfs_telldir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_telldir, 3.4.0);
 
 void
-glfs_seekdir (glfs_fd_t *fd, long offset) __THROW
-        GFAPI_PUBLIC(glfs_seekdir, 3.4.0);
+glfs_seekdir(glfs_fd_t *fd, long offset) __THROW
+    GFAPI_PUBLIC(glfs_seekdir, 3.4.0);
 
 int
-glfs_closedir (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_closedir, 3.4.0);
+glfs_closedir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_closedir, 3.4.0);
 
 int
-glfs_statvfs (glfs_t *fs, const char *path, struct statvfs *buf) __THROW
-        GFAPI_PUBLIC(glfs_statvfs, 3.4.0);
+glfs_statvfs(glfs_t *fs, const char *path, struct statvfs *buf) __THROW
+    GFAPI_PUBLIC(glfs_statvfs, 3.4.0);
 
 int
-glfs_chmod (glfs_t *fs, const char *path, mode_t mode) __THROW
-        GFAPI_PUBLIC(glfs_chmod, 3.4.0);
+glfs_chmod(glfs_t *fs, const char *path, mode_t mode) __THROW
+    GFAPI_PUBLIC(glfs_chmod, 3.4.0);
 
 int
-glfs_fchmod (glfs_fd_t *fd, mode_t mode) __THROW
-        GFAPI_PUBLIC(glfs_fchmod, 3.4.0);
+glfs_fchmod(glfs_fd_t *fd, mode_t mode) __THROW
+    GFAPI_PUBLIC(glfs_fchmod, 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);
+glfs_chown(glfs_t *fs, const char *path, uid_t uid, gid_t gid) __THROW
+    GFAPI_PUBLIC(glfs_chown, 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);
+glfs_lchown(glfs_t *fs, const char *path, uid_t uid, gid_t gid) __THROW
+    GFAPI_PUBLIC(glfs_lchown, 3.4.0);
 
 int
-glfs_fchown (glfs_fd_t *fd, uid_t uid, gid_t gid) __THROW
-        GFAPI_PUBLIC(glfs_fchown, 3.4.0);
+glfs_fchown(glfs_fd_t *fd, uid_t uid, gid_t gid) __THROW
+    GFAPI_PUBLIC(glfs_fchown, 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);
+glfs_utimens(glfs_t *fs, const char *path,
+             const struct timespec times[2]) __THROW
+    GFAPI_PUBLIC(glfs_utimens, 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);
+glfs_lutimens(glfs_t *fs, const char *path,
+              const struct timespec times[2]) __THROW
+    GFAPI_PUBLIC(glfs_lutimens, 3.4.0);
 
 int
-glfs_futimens (glfs_fd_t *fd, const struct timespec times[2]) __THROW
-        GFAPI_PUBLIC(glfs_futimens, 3.4.0);
+glfs_futimens(glfs_fd_t *fd, const struct timespec times[2]) __THROW
+    GFAPI_PUBLIC(glfs_futimens, 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);
+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_lgetxattr (glfs_t *fs, const char *path, const char *name, void *value,
-                size_t size) __THROW
-        GFAPI_PUBLIC(glfs_lgetxattr, 3.4.0);
+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_fgetxattr (glfs_fd_t *fd, const char *name, void *value,
-                size_t size) __THROW
-        GFAPI_PUBLIC(glfs_fgetxattr, 3.4.0);
+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_listxattr (glfs_t *fs, const char *path, void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_listxattr, 3.4.0);
+glfs_listxattr(glfs_t *fs, const char *path, void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_listxattr, 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);
+glfs_llistxattr(glfs_t *fs, const char *path, void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_llistxattr, 3.4.0);
 
 ssize_t
-glfs_flistxattr (glfs_fd_t *fd, void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_flistxattr, 3.4.0);
+glfs_flistxattr(glfs_fd_t *fd, void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_flistxattr, 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);
+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_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);
+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_fsetxattr (glfs_fd_t *fd, const char *name, const void *value,
-                size_t size, int flags) __THROW
-        GFAPI_PUBLIC(glfs_fsetxattr, 3.4.0);
+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_removexattr (glfs_t *fs, const char *path, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_removexattr, 3.4.0);
+glfs_removexattr(glfs_t *fs, const char *path, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_removexattr, 3.4.0);
 
 int
-glfs_lremovexattr (glfs_t *fs, const char *path, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_lremovexattr, 3.4.0);
+glfs_lremovexattr(glfs_t *fs, const char *path, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_lremovexattr, 3.4.0);
 
 int
-glfs_fremovexattr (glfs_fd_t *fd, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_fremovexattr, 3.4.0);
+glfs_fremovexattr(glfs_fd_t *fd, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_fremovexattr, 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);
+    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);
+    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, future);
+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);
+    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, future);
+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);
+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);
+glfs_fchdir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_fchdir, 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);
+glfs_posix_lock(glfs_fd_t *fd, int cmd, struct flock *flock) __THROW
+    GFAPI_PUBLIC(glfs_posix_lock, 3.4.0);
 
 /*
   SYNOPSIS
@@ -909,24 +1050,19 @@ glfs_posix_lock (glfs_fd_t *fd, int cmd, struct flock *flock) __THROW
  */
 
 /* Lock modes used by glfs_file_lock() */
-enum glfs_lock_mode {
-        GLFS_LK_ADVISORY = 0,
-        GLFS_LK_MANDATORY
-};
+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_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);
+glfs_free(void *ptr) __THROW GFAPI_PUBLIC(glfs_free, 3.7.16);
 
 /*
  * glfs_sysrq: send a system request to the @fs instance
@@ -939,13 +1075,11 @@ glfs_free (void *ptr) __THROW
  * @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);
+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
  */
@@ -953,16 +1087,17 @@ 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 (glfs_xreaddirp_stat_t *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
@@ -1007,10 +1142,10 @@ glfs_xreaddirplus_get_stat (glfs_xreaddirp_stat_t *xstat) __THROW
  *  -1: FAILURE
  */
 int
-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);
+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
 
@@ -1039,8 +1174,8 @@ glfs_xreaddirplus_r (glfs_fd_t *glfd, uint32_t flags,
  * -1: FAILURE
  */
 int
-glfs_fd_set_lkowner (glfs_fd_t *glfd, void *data, int len) __THROW
-        GFAPI_PUBLIC(glfs_fd_set_lkowner, 3.10.7);
+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
@@ -1065,20 +1200,20 @@ glfs_fd_set_lkowner (glfs_fd_t *glfd, void *data, int len) __THROW
 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);
+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_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);
-
+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,
@@ -1092,13 +1227,14 @@ glfs_upcall_get_reason (glfs_upcall_t *arg) __THROW
  *      ==========================================================
  *      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);
+void *
+glfs_upcall_get_event(glfs_upcall_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_get_event, 3.7.16);
 
 /*
  * SYNOPSIS
@@ -1119,13 +1255,14 @@ glfs_upcall_get_event (glfs_upcall_t *arg) __THROW
  * 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);
+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_ANY                 0xffffffff /* for all the above events */
+#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
@@ -1149,7 +1286,8 @@ typedef void (*glfs_upcall_cbk) (glfs_upcall_t *up_arg, void *data);
  *
  * @event_list: List of upcall events to be registered.
  *              Current available values are:
- *               - GFAPI_UPCALL_INODE_INVALIDATE
+ *               - 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
@@ -1161,9 +1299,9 @@ typedef void (*glfs_upcall_cbk) (glfs_upcall_t *up_arg, void *data);
  * -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);
+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
@@ -1183,39 +1321,41 @@ glfs_upcall_register (glfs_t *fs, uint32_t event_list, glfs_upcall_cbk cbk,
  *
  * @event_list: List of upcall events to be unregistered.
  *              Current available values are:
- *               - GFAPI_UPCALL_INODE_INVALIDATE
+ *               - 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);
+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_RD_LEASE = 1,
-        GLFS_RW_LEASE = 2,
+    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,
+    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;
+    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);
+typedef void (*glfs_recall_cbk)(glfs_lease_t lease, void *data);
 
 /*
   SYNOPSIS
@@ -1260,9 +1400,86 @@ typedef void (*glfs_recall_cbk) (glfs_lease_t lease, void *data);
   <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);
+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 a4affc277bf..c8cdc3f89fa 100755
--- a/autogen.sh
+++ b/autogen.sh
@@ -85,7 +85,7 @@ $TOOL --automake --copy --force
 echo Running ${AUTOCONF}...
 $AUTOCONF
 echo Running ${AUTOMAKE}...
-$AUTOMAKE --add-missing --force-missing --copy --foreign
+$AUTOMAKE --add-missing --force-missing --copy
 
 # Instruct user on next steps
 echo
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 6be070f6ff7..16063f27c7f 100644
--- a/cli/src/Makefile.am
+++ b/cli/src/Makefile.am
@@ -1,12 +1,11 @@
-if WITH_SERVER
 sbin_PROGRAMS = gluster
-endif
 
 gluster_SOURCES = cli.c registry.c input.c cli-cmd.c cli-rl.c cli-cmd-global.c \
 	 cli-cmd-volume.c cli-cmd-peer.c cli-rpc-ops.c cli-cmd-parser.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)
@@ -15,13 +14,14 @@ 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)\"
+	-DGLFSHEAL_PREFIX=\"$(GLUSTERFS_LIBEXECDIR)\"\
+	-DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE)
 
 AM_CFLAGS = -Wall $(GF_CFLAGS) $(XML_CFLAGS)
 
@@ -30,5 +30,8 @@ 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 16b0cc81cd6..34620b4a31b 100644
--- a/cli/src/cli-cmd-parser.c
+++ b/cli/src/cli-cmd-parser.c
@@ -18,2697 +18,2751 @@
 #include "cli.h"
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
-#include "dict.h"
-#include "list.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;
+    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                 *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;
-                }
+    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");
-                        GF_FREE (tmp_host);
-                        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);
-                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;
-                        }
-                }
+    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;
+    }
 
-                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);
+    strcat(*ta_brick, " ");
+    strcat(*ta_brick, brick->name);
+    strcat(*ta_brick, " ");
+out:
+    if (tmp_host) {
+        GF_FREE(tmp_host);
+        tmp_host = NULL;
+    }
+    if (brick) {
+        GF_FREE(brick);
+        brick = NULL;
+    }
+
+    return ret;
+}
 
-                brick_list_len += len + 1; /* Brick name + space */
-                ++(*brick_count);
-                ++brick_index;
+int32_t
+cli_cmd_bricks_parse(const char **words, int wordcount, int brick_index,
+                     char **bricks, int *brick_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;
         }
 
-        brick_list_len++; /* For terminating null char */
-
-        bricks_str = GF_MALLOC(brick_list_len, gf_common_mt_char);
-        if (bricks_str == NULL) {
+        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;
-                gf_log("cli", GF_LOG_ERROR, "Out of memory");
+                cli_err("Found duplicate exports %s", words[brick_index]);
                 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);
+
+        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;
         }
-        *bricks_str = 0;
+        len = strlen(words[brick_index]);
+        brick->name = words[brick_index];
+        brick->len = len;
+        list_add_tail(&brick->list, &brick_list);
+
+        brick_list_len += len + 1; /* Brick name + space */
+        ++(*brick_count);
+        ++brick_index;
+    }
+
+    /* If brick count is not valid exit here */
+    if (!*brick_count) {
+        cli_err("No bricks specified");
+        ret = -1;
+        goto out;
+    }
+
+    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);
-        }
+    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;
+    return ret;
 }
 
 int32_t
-cli_cmd_create_disperse_check (struct cli_state *state, int *disperse,
-                               int *redundancy, int *data, int count)
+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 {
-                        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 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;
+            }
         }
+    }
 
-        if (*disperse <= 0) {
-                if (count < 3) {
-                        cli_err ("number of bricks must be greater "
-                                 "than 2");
+    if (*disperse <= 0) {
+        if (count < 3) {
+            cli_err(
+                "number of bricks must be greater "
+                "than 2");
 
-                        return -1;
-                }
-                *disperse = count;
+            return -1;
         }
+        *disperse = count;
+    }
 
-        if (*redundancy == -1) {
-                tmp = *disperse - 1;
-                for (i = tmp / 2;
-                     (i > 0) && ((tmp & -tmp) != tmp);
-                     i--, tmp--);
+    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;
-                        }
-                }
+        if (i == 0) {
+            answer = cli_cmd_get_confirmation(state, question1);
+            if (answer == GF_ANSWER_NO)
+                return -1;
 
-                tmp = 0;
+            *redundancy = 1;
         } else {
-                tmp = *disperse - *redundancy;
+            *redundancy = *disperse - tmp;
+            if (*redundancy > 1) {
+                sprintf(question, question2, *redundancy);
+                answer = cli_cmd_get_confirmation(state, question);
+                if (answer == GF_ANSWER_NO)
+                    return -1;
+            }
         }
 
-        if (*redundancy > (*disperse - 1) / 2) {
-                cli_err ("redundancy must be less than %d for a "
-                         "disperse %d volume",
-                         (*disperse + 1) / 2, *disperse);
+        tmp = 0;
+    } else {
+        tmp = *disperse - *redundancy;
+    }
 
-                return -1;
-        }
+    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);
 
-        if ((tmp & -tmp) != tmp) {
-                answer = cli_cmd_get_confirmation(state, question3);
-                if (answer == GF_ANSWER_NO)
-                        return -1;
-        }
+        return -1;
+    }
 
-        return 0;
+    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;
-                        }
-
-                        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;
-                                        }
-                                        ret = dict_set_int32 (dict, "arbiter-count",
-                                                              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) {
-                                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) {
-                        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_int32 (dict, "force", is_force);
+    ret = dict_set_dynstr(dict, "bricks", bricks);
+    if (ret)
+        goto out;
+
+    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_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");
+    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;
-                }
-                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;
+                    }
+                } 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;
 
-        GF_FREE(daemon_name);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    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) {
-
-                if ((wordcount == 3) && !(strcmp (words[2], "help"))) {
-                        ret = 1;
-                }
-                goto out;
-        }
+    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;
+    }
 
-        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 (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 (wordcount < 6 || wordcount > 7) {
-                        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 (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[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;
+            }
+        }
 
-                if (!words[5]) {
-                        cli_err ("Please enter the limit value to be set");
-                        ret = -1;
-                        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) {
-                        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;
-                        }
-                }
+        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;
+            }
 
-                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) {
+        goto set_type;
+    }
 
-                        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;
-                        }
+    if (strcmp(w, "remove") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
 
-                        ret = dict_set_str (dict, "soft-limit",
-                                            (char *) words[6]);
-                        if (ret < 0)
-                                goto out;
-                }
+        type = GF_QUOTA_OPTION_TYPE_REMOVE;
 
-                goto set_type;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "remove") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                type = GF_QUOTA_OPTION_TYPE_REMOVE;
+    if (strcmp(w, "remove-objects") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
 
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+        type = GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS;
 
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "remove-objects") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                type = GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS;
+    if (strcmp(w, "list") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIST;
 
-                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;
+        if (words[4] && words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "list") == 0) {
+        i = 4;
+        while (i < wordcount) {
+            snprintf(key, 20, "path%d", i - 4);
 
-                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) {
+        type = GF_QUOTA_OPTION_TYPE_LIST_OBJECTS;
 
-                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) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to set "
+                       "quota patch in request dictionary");
+                goto out;
+            }
         }
 
-        if (strcmp (w, "list-objects") == 0) {
-                type = GF_QUOTA_OPTION_TYPE_LIST_OBJECTS;
-
-                i = 4;
-                while (i < wordcount) {
-                        snprintf (key, 20, "path%d", i-4);
-
-                        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;
-                        }
-                }
-
-                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;
-                }
-
-                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 int32_t
 cli_add_key_group_value(dict_t *dict, const char *name, const char *value,
                         int32_t id, char **op_errstr)
 {
-        char         *key  = NULL;
-        char         *data = NULL;
-        int32_t       ret  = -1;
+    char *key = NULL;
+    char *data = NULL;
+    int32_t ret = -1;
 
-        ret = gf_asprintf(&key, "%s%d", name, id);
-        if (ret < 0) {
-                goto out;
-        }
-        data = gf_strdup(value);
-        if (data == NULL) {
-                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;
+    }
 
-        ret = dict_set_dynstr(dict, key, data);
-        if (ret == 0) {
-                data = NULL;
-        }
+    ret = dict_set_dynstr(dict, key, data);
+    if (ret == 0) {
+        data = NULL;
+    }
 
 out:
-        GF_FREE(key);
-        GF_FREE(data);
+    GF_FREE(key);
+    GF_FREE(data);
 
-        if ((ret != 0) && (op_errstr != NULL)) {
-                *op_errstr = gf_strdup("Failed to allocate memory");
-        }
+    if ((ret != 0) && (op_errstr != NULL)) {
+        *op_errstr = gf_strdup("Failed to allocate memory");
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-cli_add_key_group (dict_t *dict, char *key, char *value, char **op_errstr)
+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;
-        }
-
-        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));
-                }
-                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;
-                }
-                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;
-                }
+    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;
+    }
 
-                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;
-                }
+    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));
         }
-
-        if (!opt_count) {
-                ret = -1;
-                if (op_errstr) {
-                        gf_asprintf(op_errstr, "'%s' file format not valid.",
-                                    tagpath);
-                }
-                goto out;
+        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);
         }
-        ret = dict_set_int32 (dict, "count", opt_count);
+        goto out;
+    }
+    ret = dict_set_int32(dict, "count", opt_count);
 out:
 
-        GF_FREE (tagpath);
+    GF_FREE(tagpath);
 
-        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;
-                }
+    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;
 
-                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;
-                }
-        }
+    if (wordcount < 3)
+        goto out;
 
-        if ((!strcmp (volname, "help") || !strcmp (volname, "help-xml"))
-            && wordcount == 3 ) {
-                ret = dict_set_str (dict, volname, volname);
-                if (ret)
-                        goto out;
+    volname = (char *)words[2];
 
-        } else if (wordcount < 5) {
-                ret = -1;
-                goto out;
+    GF_ASSERT(volname);
 
-        } 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;
-                }
+    ret = dict_set_str(dict, "volname", volname);
 
-                ret = gf_strip_whitespace (value, strlen (value));
-                if (ret == -1)
-                        goto out;
-
-                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;
+            goto out;
 
-        *options = dict;
+    } else if (wordcount < 5) {
+        ret = -1;
+        goto out;
 
-out:
-        if (ret && dict)
-                dict_unref (dict);
+    } 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;
+        }
 
-        return ret;
-}
+        ret = gf_strip_whitespace(value, strlen(value));
+        if (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;
-
-        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);
+    }
 
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "count", wordcount - 3);
 
-        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 && dict)
+        dict_unref(dict);
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse add-brick CLI");
-                if (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 = dict_new ();
+    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;
 
-        if (!dict)
-                goto out;
+    if (wordcount < 3)
+        goto out;
 
-        if (!(wordcount == 4 || wordcount == 5)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                ret = -1;
-                goto out;
-        }
+    volname = (char *)words[2];
 
-        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;
-
-        *options = dict;
-out:
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse tier CLI");
-                if (dict)
-                        dict_unref (dict);
+            index = 7;
         }
 
-        return ret;
-}
+        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;
+    }
 
-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;
+    brick_index = index;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+parse_bricks:
 
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    if (strcmp(words[wordcount - 1], "force") == 0) {
+        is_force = _gf_true;
+        wc = wordcount - 1;
+    }
 
-        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, int32_t *comm)
+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;
-                        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 {
-                        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);
 
-        *comm = command;
+    *comm = command;
 
-        return ret;
+    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 (wordcount < 5 || wordcount > 7)
+        goto out;
 
-        if (!dict)
-                goto out;
+    dict = dict_new();
 
-        volname = (char *)words[2];
+    if (!dict)
+        goto out;
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    volname = (char *)words[2];
 
-        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, -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)
+gsyncd_url_check(const char *w)
 {
-        return !!strpbrk (w, ":/");
+    return !!strpbrk(w, ":/");
 }
 
 static gf_boolean_t
-gsyncd_glob_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)
+{
+    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);
-                if (ret != 0) {
-                        goto out;
-                }
-                append_str = NULL;
-        }
+            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:
-        GF_FREE (append_str);
-        GF_FREE (subop);
+    GF_FREE(append_str);
+    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.
@@ -2717,1522 +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]);
-                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 (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);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        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", "client-list",
-                                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    },
-                { "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;
-        }
+    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;
-
-        GF_ASSERT (options);
+    dict_t *dict = NULL;
+    int ret = -1;
+    uint32_t cmd = 0;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    GF_ASSERT(options);
 
-        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;
+            cmd = cli_cmd_get_statusop(words[3]);
 
-                } 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[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 = 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)
-                   && 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 {
-                        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;
-                        }
-                        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 ((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;
+            }
+            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_dynstr (dict, "options", option_str);
-        if (ret)
-                goto out;
-        option_str = NULL;
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "option_cnt", option_cnt);
-        if (ret)
-                goto out;
+    /* 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;
 
-        *options = dict;
+    ret = dict_set_int32(dict, "option_cnt", option_cnt);
+    if (ret)
+        goto out;
+
+    *options = dict;
 out:
-        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;
+    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;
-                hostname = NULL;
-                ret = dict_set_dynstr (dict, "heal-source-brickpath",
-                                       path);
-                if (ret) {
-                        goto out;
-                }
-                path = NULL;
-                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;
-                hostname = NULL;
-                ret = dict_set_dynstr (dict, "per-replica-cmd-path",
-                                       path);
-                if (ret) {
-                        goto out;
-                }
-                path = NULL;
-                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:
-        GF_FREE(hostname);
-        GF_FREE(path);
-        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;
-
-        ret = dict_set_str (dict, "volname", (char *) words[2]);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set volname");
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to create the dict");
+        ret = -1;
+        goto out;
+    }
 
-        if (wordcount == 3) {
-                ret = dict_set_int32 (dict, "heal-op", GF_SHD_OP_HEAL_INDEX);
-                goto done;
-        }
+    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 == 4) {
-                op = heal_command_type_get (words[3]);
-                if (op == GF_SHD_OP_INVALID) {
-                        ret = -1;
-                        goto out;
-                }
+    if (wordcount == 3) {
+        ret = dict_set_int32(dict, "heal-op", GF_SHD_OP_HEAL_INDEX);
+        goto done;
+    }
 
-                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[4], "summary")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                                   GF_SHD_OP_HEAL_SUMMARY);
-                                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]);
-        }
+    int32_t ret = -1;
+    char *desc = NULL;
+    int32_t desc_len = 0;
+    int len;
 
-        strncpy (desc, words[desc_opt_loc], desc_len);
-        desc[desc_len] = '\0';
-        /* 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;
-        }
+    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>
@@ -4244,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;
-        }
-
-        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;
-        }
+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;
+    }
 
-        /* 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;
-        }
+    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;
+    }
+
+    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.
@@ -4320,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], "force") == 0) {
+        flags = GF_CLI_FLAG_OP_FORCE;
 
-        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;
-
-        } 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]
@@ -4497,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>)]
@@ -4532,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.
@@ -4622,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]
@@ -4669,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>
@@ -4718,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>)
@@ -4766,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;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+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;
 
-        if (wordcount > 4 || wordcount <= cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        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>)]
@@ -4849,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;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-        GF_ASSERT (key);
+    int ret = -1;
+    int limit = 0;
+    char *end_ptr = NULL;
 
-        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;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+    GF_ASSERT(key);
 
-        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
@@ -4990,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 06e00c96b7e..859d6b2e40d 100644
--- a/cli/src/cli-cmd-snapshot.c
+++ b/cli/src/cli-cmd-snapshot.c
@@ -17,149 +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];
-
-        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 c41594bfa59..801e8f4efed 100644
--- a/cli/src/cli-cmd-system.c
+++ b/cli/src/cli-cmd-system.c
@@ -18,604 +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");
+    }
+
+    if (dict)
+        dict_unref(dict);
 
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    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");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    CLI_STACK_DESTROY(frame);
+
+    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);
-        if (command == NULL) {
-                gf_log("cli", GF_LOG_ERROR, "Failed to parse command");
-                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);
-
-        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++;
-                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->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);
-
-                /* 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;
-        }
+            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:
-        if (dict != NULL) {
-                dict_unref(dict);
-        }
+    if (dict != NULL) {
+        dict_unref(dict);
+    }
 
-        return ret;
+    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 70a7a1a19d7..f238851586e 100644
--- a/cli/src/cli-cmd-volume.c
+++ b/cli/src/cli-cmd-volume.c
@@ -23,3185 +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;
-
-        ret = cli_cmd_volume_create_parse (state, words, wordcount, &options,
-                                           &bricks);
+    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;
+    }
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                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;
+    }
 
-        ret = dict_get_str (options, "transport", &trans_type);
+    if (state->mode & GLUSTER_MODE_WIGNORE) {
+        ret = dict_set_int32(options, "force", _gf_true);
         if (ret) {
-                gf_log("cli", GF_LOG_ERROR, "Unable to get transport type");
-                goto out;
+            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;
-                }
-        }
+    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");
-        }
-
-        if (ret == 0) {
-                gf_event (EVENT_VOLUME_CREATE, "name=%s;bricks=%s",
-                          (char *)words[2], bricks);
-        }
-
-        CLI_STACK_DESTROY (frame);
-        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");
-        }
-
-        CLI_STACK_DESTROY (frame);
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume profile failed");
+    }
 
-        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_event(EVENT_VOLUME_ADD_BRICK, "%s", event_str);
 #endif
-        }
+    }
 #if (USE_EVENTS)
-        GF_FREE(event_str);
+    GF_FREE(event_str);
 #endif
 
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_tier_validate_replica_type (dict_t *dict, int type)
+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;
+    }
 
-        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;
-}
-
-int
-do_cli_cmd_volume_attach_tier (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                     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];
-
-        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");
-        }
-
-        CLI_STACK_DESTROY (frame);
+    if (fd != -1)
+        sys_close(fd);
 
-        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;
-}
+    volname_dup = gf_strdup(volname);
+    if (!volname_dup) {
+        ret = -1;
+        goto out;
+    }
 
-/* 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;
+    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;
+    }
 
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        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 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 (gfid_type_stored == gfid_type) {
-                        limits_set = _gf_true;
-                        break;
-                }
-        }
-out:
-        if (fd != -1)
-                sys_close (fd);
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        return limits_set;
-}
+    CLI_LOCAL_INIT(local, words, frame, xdata);
+    proc = &cli_quotad_clnt.proctable[GF_AGGREGATOR_GETLIMIT];
 
-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;
-        }
+    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_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;
         }
 
-        ret = dict_get_int32 (options, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota option type");
-                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 = dict_set_int32 (xdata, "type", type);
+        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 type in xdata");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to set gfid");
+            goto out;
         }
 
-        ret = cli_get_soft_limit (options, words, xdata);
+        ret = proc->fn(frame, THIS, xdata);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch default "
-                        "soft-limit");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to get quota "
+                   "limits for %s",
+                   uuid_utoa((unsigned char *)buf));
         }
 
-        /* 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;
-        }
+        dict_del(xdata, "gfid");
+        all_failed = all_failed && ret;
+    }
 
-        volname_dup = gf_strdup (volname);
-        if (!volname_dup) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_dynstr (xdata, "volume-uuid", volname_dup);
+    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 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;
-        }
-
-        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;
-
-        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];
+    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
-        int32_t                 command = GF_OP_CMD_NONE;
-        char                    *question = NULL;
-
-        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,
-                                                 &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 = "Running remove-brick with cluster.force-migration"
-                           " enabled can result in data corruption. It is safer"
-                           " to disable this option so that files that receive "
-                           "writes during migration are not migrated.\nFiles "
-                           "that are not migrated can then be manually copied "
-                           "after the remove-brick commit operation.\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;
-        }
+    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) {
-                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];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_BRICK];
 
+    ret = cli_cmd_volume_reset_brick_parse(words, wordcount, &options);
 
-        ret = cli_cmd_volume_reset_brick_parse (words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
+    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;
-                }
-
-                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);
-                }
-
-                /* Allocated by gf_strdup and gf_asprintf */
-                GF_FREE (events_str);
-        }
-#endif
+                    tmp = "";
 
-        CLI_STACK_DESTROY (frame);
+                /* For Config Set additionally capture key and value */
+                /* For Config Reset capture key */
+                if (strcmp(tmp, "set") == 0) {
+                    event_type = EVENT_GEOREP_CONFIG_SET;
 
-        return ret;
-}
+                    ret1 = dict_get_str(options, "op_name", &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, "%soption=%s;", events_str,
+                                       tmp);
 
-        ret = cli_cmd_volume_status_parse (words, wordcount, &dict);
+                    ret1 = dict_get_str(options, "op_value", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
+                    gf_asprintf_append(&events_str, "%svalue=%s;", events_str,
+                                       tmp);
+                } else if (strcmp(tmp, "del") == 0) {
+                    event_type = EVENT_GEOREP_CONFIG_RESET;
 
-        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;
-
-        snprintf (key, sizeof (key), "brick%d.free", i);
-        ret = dict_get_uint64 (dict, key, &free);
+    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;
 
-        status->free = gf_uint64_2human_readable (free);
-        if (!status->free)
-                goto out;
-
-        snprintf (key, sizeof (key), "brick%d.total", i);
-        ret = dict_get_uint64 (dict, key, &total);
+    ret = cli_cmd_volume_status_parse(words, wordcount, &dict);
 
-        status->total = gf_uint64_2human_readable (total);
-        if (!status->total)
-                goto out;
+    if (ret) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        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;
 
-        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];
+    }
 
-        snprintf (key, sizeof (key), "brick%d.mnt_options", i);
-        ret = dict_get_str (dict, key, &(status->mount_options));
-        if (ret)
-                status->mount_options = NULL;
+    if (!proc->fn) {
+        ret = -1;
+        goto out;
+    }
 
-        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;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+        ret = -1;
+        goto out;
+    }
 
-        snprintf (key, sizeof (key), "brick%d.inode_size", i);
-        ret = dict_get_str (dict, key, &(status->inode_size));
-        if (ret)
-                status->inode_size = NULL;
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        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;
-        }
+    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) || \
-                             (op == GF_SHD_OP_HEAL_SUMMARY))
+#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;
+            runner_add_args(&runner, "info-summary", NULL);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "--xml", NULL);
+            }
+            break;
         default:
-                ret = -1;
-                goto out;
-        }
-        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
@@ -3210,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|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 }
-};
+    {"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 1bb9bf07c51..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 "gf-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 9812bbdab18..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,9670 +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);
+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
-add_cli_cmd_timeout_to_dict (dict_t *dict);
+static int
+add_cli_cmd_timeout_to_dict(dict_t *dict);
 
-rpc_clnt_prog_t cli_handshake_prog = {
-        .progname  = "cli handshake",
-        .prognum   = GLUSTER_HNDSK_PROGRAM,
-        .progver   = GLUSTER_HNDSK_VERSION,
+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++) {
-                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);
 
-                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)) {
-                        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++;
+        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;
-        }
+    flags = (long)frame->local;
 
-        /* 'free' the flags set by gf_cli_list_friends */
-        frame->local = NULL;
+    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;
+    }
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    /* 'free' the flags set by gf_cli_list_friends */
+    frame->local = NULL;
 
-        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;
+    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;
+    }
+
+    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, XML_ERROR);
                 goto out;
+            }
+            cli_err("%s", msg);
+            ret = 0;
+            goto out;
         }
 
-        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;
-                }
-
-                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) {
-                snprintf (key, 1024, "volume%d.brick%d", volcount, index);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret)
-                        goto out;
-                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;
-}
-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);
-               }
-       }
-
+    return ret;
 }
 
-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);
-
-        snprintf (key, sizeof (key), "volume%d.cold_brick_count", i);
-        ret = dict_get_int32 (dict, key, &cold_brick_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_type", i);
-        ret = dict_get_int32 (dict, key, &cold_type);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_dist_count", i);
-        ret = dict_get_int32 (dict, key, &cold_dist_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_replica_count", i);
-        ret = dict_get_int32 (dict, key, &cold_replica_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_arbiter_count", i);
-        ret = dict_get_int32 (dict, key, &cold_arbiter_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_disperse_count", i);
-        ret = dict_get_int32 (dict, key, &cold_disperse_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key),
-                  "volume%d.cold_redundancy_count", i);
-        ret = dict_get_int32 (dict, key,
-                              &cold_redundancy_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.hot_brick_count", i);
-        ret = dict_get_int32 (dict, key, &hot_brick_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.hot_type", i);
-        ret = dict_get_int32 (dict, key, &hot_type);
-        if (ret)
-                goto out;
-        snprintf (key, sizeof (key), "volume%d.hot_replica_count", i);
-        ret = dict_get_int32 (dict, key, &hot_replica_count);
-        if (ret)
-                goto out;
-
-        cli_out ("Hot Tier :");
-        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);
-
-        ret = print_brick_details (dict, i, 1, hot_brick_count,
-                                   hot_replica_count);
-        if (ret)
-                goto out;
-
-        cli_out ("Cold Tier:");
-
-        vol_type = get_vol_type (cold_type, cold_dist_count, cold_brick_count);
-        cli_out ("Cold Tier Type : %s",
-                        vol_type_str[vol_type]);
-
-        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);
-
-        ret = print_brick_details (dict, i, hot_brick_count+1,
-                                   brick_count, cold_replica_count);
-        if (ret)
-                goto out;
-out:
-        return ret;
+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_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)
-                goto out;
+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;
+    }
 
-        frame = myframe;
+    dict = dict_new();
 
-        GF_ASSERT (frame->local);
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        local = frame->local;
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-        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 (ret) {
+        gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to get vol: %d",
-                rsp.op_ret);
+    ret = dict_get_int32_sizen(dict, "count", &count);
+    if (ret)
+        goto out;
 
-        if (!rsp.dict.dict_len) {
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-                cli_err ("No volumes present");
+    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;
-        }
 
-        dict = dict_new ();
-
-        if (!dict) {
+            case GF_CLI_GET_VOLUME:
+                snprintf(err_str, sizeof(err_str), "Volume %s does not exist",
+                         local->get_vol.volname);
                 ret = -1;
-                goto out;
+                if (!(global_state->mode & GLUSTER_MODE_XML))
+                    goto out;
         }
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
+    if (rsp.op_ret) {
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
+        ret = -1;
+        goto out;
+    }
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unable to allocate memory");
+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;
+            }
         }
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret)
+        if (dict) {
+            ret = cli_xml_output_vol_info(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
                 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:
-                        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;
+        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;
+    }
 
-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;
-                        }
-                }
-
-                if (dict) {
-                        ret = cli_xml_output_vol_info (local, dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto out;
-                        }
-                }
+    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;
 
-                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.type", i);
+        ret = dict_get_int32n(dict, key, keylen, &type);
+        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.status", i);
+        ret = dict_get_int32n(dict, key, keylen, &status);
+        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.brick_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &brick_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.dist_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &dist_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.stripe_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &stripe_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.replica_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &replica_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.disperse_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &disperse_count);
+        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.redundancy_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &redundancy_count);
+        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.arbiter_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &arbiter_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.transport", i);
+        ret = dict_get_int32n(dict, key, keylen, &transport);
+        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;
+        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.transport", i);
-                ret = dict_get_int32 (dict, key, &transport);
-                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.volume_id", i);
-                ret = dict_get_str (dict, key, &volume_id_str);
-                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, 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);
 
-                // 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);
 
-                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);
+        gf_cli_print_number_of_bricks(
+            type, brick_count, dist_count, stripe_count, replica_count,
+            disperse_count, redundancy_count, arbiter_count);
 
-#ifdef HAVE_BD_XLATOR
-                k = 0;
-                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 {
-                                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);
-
-                        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");
-
-        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("volDelete", 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 ("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;
-        }
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict get failed");
+        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;
-
-        GF_ASSERT (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;
 
-        if (-1 == req->rpc_status)
-                goto out;
+    GF_ASSERT(myframe);
 
-        frame = 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,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    local = frame->local;
 
-        frame->local = NULL;
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to uuid get");
+    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;
-        }
+    frame->local = NULL;
 
-        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;
-        }
+    gf_log("cli", GF_LOG_INFO, "Received resp to uuid get");
 
-        ret = dict_get_str (dict, "uuid", &uuid_str);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get uuid "
-                        "from dictionary");
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        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;
-        }
+    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 (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;
+    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", 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_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);
+    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_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 = 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");
+    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) {
-                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 ("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_log("cli", GF_LOG_INFO, "Received resp to stop volume");
 
-        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);
-
-        ret = rsp.op_ret;
-
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
-
-        return ret;
-}
-
-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;
-        }
-
-        snprintf (key, sizeof (key), "status-1");
-
-        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 */
-                snprintf (key, sizeof (key), "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);
 
-                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");
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-                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");
+    return ret;
+}
 
-                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");
+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");
 
-                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");
+        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");
 
-                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");
+        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");
 
-                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");
+        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");
 
-                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");
-
-                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 */
-                snprintf (key, sizeof (key), "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;
-
-                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), "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), "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");
 
-                snprintf (key, sizeof (key), "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;
 
-                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");
+        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;
-                }
-        }
-
-        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 (ret) {
-                        gf_log ("cli", GF_LOG_WARNING,
-                                "failed to get %s from dict",
-                                GF_REBALANCE_TID_KEY);
-                        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
-                                 */
-                                 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);
-                }
+            gf_log("cli", GF_LOG_WARNING, "failed to get %s from dict",
+                   GF_REBALANCE_TID_KEY);
         }
-        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;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    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;
-}
-
-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);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "failed to unserialize volume set respone dict");
-                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 (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,
-                                "Error outputting to xml");
-                goto out;
-        }
+    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 (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);
-                }
-        }
+    if (rsp.op_ret)
+        cli_err("volume reset: failed: %s", msg);
+    else
+        cli_out("volume reset: success: %s", msg);
 
-        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_log ("cli", GF_LOG_INFO, "Received resp to attach tier");
-
-        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");
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
 
-        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;
+    GF_ASSERT(myframe);
 
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
-}
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-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,};
-
-        GF_VALIDATE_OR_GOTO ("cli", myframe, 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 (-1 == req->rpc_status) {
-                goto out;
-        }
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to ganesha");
 
-        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;
-
-        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;
-        }
-
-
-        if (rsp.dict.dict_len) {
-                rsp_dict = dict_new ();
-                if (!rsp_dict) {
-                        ret = -1;
-                        goto out;
-                }
+    frame = myframe;
+    local = frame->local;
+    words = (char **)local->words;
 
-                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;
-                }
+    while (*words != NULL) {
+        if (strstr(*words, "trace") == NULL &&
+            strstr(*words, "error-gen") == NULL) {
+            words++;
+            continue;
         }
 
-        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));
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                rsp.op_ret = -1;
-                                goto xml_output;
-                        }
-
-                        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_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 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)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    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;
 
-        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;
+    GF_ASSERT(myframe);
 
-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;
-        }
+    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_int32 (local->dict, "command", &command);
-        if (ret)
-                goto out;
+    ret = dict_get_int32_sizen(local->dict, "command", &command);
+    if (ret)
+        goto out;
 
-        cmd = command;
+    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;
-        }
-
-        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;
-                }
+            gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            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);
-
-        return ret;
-}
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-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;
-        }
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        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);
-                        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;
-                        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;
+        }
+    }
+
+    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;
+    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 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".
-                         */
-
-                        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;
-        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:
-        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);
+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_ERROR, "Failed to get type");
-                goto out;
+            gf_log("cli", GF_LOG_WARNING, "limit key not present in dict on %s",
+                   path);
+            goto out;
         }
-
-        ret = dict_get_str (rsp_dict, GET_ANCESTRY_PATH_KEY, &path);
+    } else {
+        ret = dict_get_bin(rsp_dict, QUOTA_LIMIT_OBJECTS_KEY,
+                           (void **)&size_limits);
         if (ret) {
-                gf_log ("cli", GF_LOG_WARNING, "path key is not present "
-                        "in dict");
-                goto out;
-        }
-
-        ret = dict_get_str (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,
-                                "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 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);
-        }
-
-        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 = add_cli_cmd_timeout_to_dict (dict);
+    dict = data;
+    ret = add_cli_cmd_timeout_to_dict(dict);
 
-        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");
+    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;
-        }
+        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 && 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 %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);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to serialize dict");
-                goto out;
-        }
+    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;
+    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_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;
-
-        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_create_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_CREATE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    dict = data;
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", 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_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_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);
+    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);
 
-out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", 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;
-        }
-
-        dict = data;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *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);
+    dict = data;
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    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);
 
-        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;
-
-        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_defrag_volume_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);
+    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);
 
-        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;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        dict = data;
+    if (!frame || !this || !data) {
+        ret = -1;
+        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,
-                        "failed to serialize the data");
+    dict = 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)
+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;
+    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_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;
+    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_set_volume (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;
-
-        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);
+    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_add_brick (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;
-
-        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);
-
-        GF_FREE (req.dict.dict_val);
-
-        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;
-        }
-
-        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);
-
-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_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);
 
-        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;
-}
-
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-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;
-
-        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_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_FREE (status_req.dict.dict_val);
-
-        return ret;
-}
-
-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)) {
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
+    GF_FREE(req.dict.dict_val);
 
-                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;
+    GF_FREE(status_req.dict.dict_val);
 
-                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);
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        GF_FREE (req.dict.dict_val);
+    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);
 
-        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;
-
-        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_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++) {
-                snprintf (key, sizeof (key), "log%d-old-state", i);
-                ret = dict_get_str (dict, key, &old_state);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "log%d-event", i);
-                ret = dict_get_str (dict, key, &event);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "log%d-new-state", i);
-                ret = dict_get_str (dict, key, &new_state);
-                if (ret)
-                        goto out;
-
-                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] = "";
-
-        if (dict_get_str (dict, "subop", &subop) != 0)
-                return -1;
-
-        if (strcmp (subop, "get") != 0 && strcmp (subop, "get-all") != 0) {
-                cli_out (GEOREP" config updated successfully");
-                return 0;
-        }
+    int ret = -1;
+    gf1_cli_fsm_log_req req = {
+        0,
+    };
 
-        if (dict_get_str (dict, "glusterd_workdir", &gwd) != 0 ||
-            dict_get_str (dict, "slave", &slave) != 0)
-                return -1;
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (dict_get_str (dict, "master", &master) != 0)
-                master = NULL;
-        if (dict_get_str (dict, "op_name", &op_name) != 0)
-                op_name = NULL;
+    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 = dict_get_str (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);
+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;
-        }
+    char *slavekey1 = NULL;
+    char *slavekey2 = NULL;
 
-        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);
-                }
-        }
-
-        /* 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++) {
-                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;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+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;
+    }
 
-        if (ret)
-                goto out;
+    ret = dict_get_int32_sizen(dict, "output_count", &output_count);
+    if (ret) {
+        cli_out("Command executed successfully.");
+        ret = 0;
+        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_str_sizen(dict, "command", &command);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to get command from dict");
+        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;
-        }
-
-        if (!strcmp (command, "gsec_create")) {
-                ret = write_contents_to_common_pem_file (dict, output_count);
-                if (!ret)
-                        goto out;
+            gf_log("", GF_LOG_ERROR, "Failed to get %s.", output_name);
+            cli_out("Unable to fetch output.");
         }
-
-        for (i = 1; i <= output_count; i++) {
-                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;
-                }
+        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);
-
-        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;
-
-                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;
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                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,}};
-
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        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);
+    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);
 
-out:
-        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;
+    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)
-                ret = -1;
-        else if (ia->percentage_avg_latency > ib->percentage_avg_latency)
-                ret = 1;
-        else
-                ret = 0;
-        return ret;
-}
+    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;
 
+    return 0;
+}
 
-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-%d", count,
-                          interval, (1 << 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);
-                }
+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);
         }
+    }
 
-        for (i = 0; i < 32; i++) {
-                snprintf (key, sizeof (key), "%d-%d-write-%d", count, interval,
-                          (1<<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 < 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++) {
-                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];
+    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];
+    }
 
-        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);
-                }
-
-                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);
-                }
-
-                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);
-                }
-
-                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 ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
-                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);
-        }
-        snprintf (key, sizeof (key), "%d-%d-duration", count, interval);
-        ret = dict_get_uint64 (dict, key, &sec);
+    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, "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);
+        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);
+            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);
+        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);
+            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, "%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;
-                        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;
-                }
+        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("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+        profile_info[i].fop_name = (char *)gf_fop_list[i];
 
-        if (per_line != 0) {
-                cli_out ("%s", output);
-                cli_out ("%s", read_blocks);
-                cli_out ("%s", write_blocks);
-        }
+        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++) {
-                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);
-                }
+            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");
         }
-
-        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 (" ");
+        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(" ");
 }
 
-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;
+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)
+            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;
         }
+    }
 
-        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;
-        }
+    if (rsp.op_ret) {
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        dict = dict_new ();
+    if (GF_CLI_STATS_INFO != op) {
+        ret = 0;
+        goto out;
+    }
 
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_get_int32_sizen(dict, "count", &brick_count);
+    if (ret)
+        goto out;
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
+    if (!brick_count) {
+        cli_err("All bricks of volume %s are down.", volname);
+        goto out;
+    }
 
-        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_sizen(dict, "info-op", (int32_t *)&info_op);
+    if (ret)
+        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,
-                                "Error outputting to xml");
-                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;
         }
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
+        ret = dict_get_str_boolean(dict, "nfs", _gf_false);
 
-        ret = dict_get_int32 (dict, "op", (int32_t*)&op);
         if (ret)
-                goto out;
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
-                cli_err ("%s", rsp.op_errstr);
+            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 {
-                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 (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 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-
-        if (!brick_count) {
-                cli_err ("All bricks of volume %s are down.", volname);
-                goto out;
-        }
-
-        while (i <= brick_count) {
-                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);
+            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;
-
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
-        dict = data;
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(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);
+    dict = data;
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    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);
 
-        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) {
-                        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;
-
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
-        dict = data;
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(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);
-
-        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++) {
-                snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
-                ret = dict_get_str (dict, key, &name);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &hotcount);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &coldcount);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
-                          prefix, i);
-                ret = dict_get_uint64 (dict, key, &paddedsizeof);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxstdalloc);
-                if (ret)
-                        goto out;
-
-                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);
-
-        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);
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.coldcount", prefix, i);
+        ret = dict_get_int32n(dict, key, keylen, &coldcount);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
+            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)
-                        continue;
-                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);
-
-                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--------");
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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), "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), "brick%d.mallinfo.fsmblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Fsmblks", val);
-
-                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);
-
-                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.paddedsizeof", prefix, i);
+        ret = dict_get_uint64(dict, key, &paddedsizeof);
+        if (ret)
+            goto out;
 
-                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);
+        snprintf(key, sizeof(key), "%s.pool%d.alloccount", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
+        if (ret)
+            goto out;
 
-                cli_out (" ");
-                snprintf (key, sizeof (key), "brick%d", i);
-                cli_print_volume_status_mempool (dict, key);
-        }
-out:
-        cli_out ("----------------------------------------------\n");
-        return;
-}
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.max_alloc", prefix, i);
+        ret = dict_get_int32n(dict, key, keylen, &maxalloc);
+        if (ret)
+            goto out;
 
-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[1024]               = {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_tierd_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 (dict, "volname", &volname);
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.max-stdalloc", prefix,
+                          i);
+        ret = dict_get_int32n(dict, key, keylen, &maxstdalloc);
         if (ret)
-                goto out;
-        cli_out ("Client connections for volume %s", volname);
+            goto out;
 
-        ret = dict_get_int32 (dict, "client-count", &client_count);
+        snprintf(key, sizeof(key), "%s.pool%d.pool-misses", prefix, i);
+        ret = dict_get_uint64(dict, key, &pool_misses);
         if (ret)
-                goto out;
+            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 (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 (dict,
-                                                        "gfapi-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strcmp(name, "tierd")) {
-                                if (!is_tierd_done) {
-                                        is_tierd_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "tierd-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 (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 (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 (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 (dict,
-                                                        "snapd-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        }
-
-print:
-                cli_out ("%-48s %15d", name, current_count);
+        cli_out("%-30s %9d %9d %12" PRIu64 " %10" PRIu64 " %8d %8" PRIu64
+                " %12d",
+                name, hotcount, coldcount, paddedsizeof, alloccount, maxalloc,
+                pool_misses, maxstdalloc);
+    }
 
-        }
 out:
-                cli_out ("\ntotal clients for volume %s : %d ", volname, total);
-                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--------");
 
-                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);
 
-                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);
-                }
-                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);
 
-                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;
-}
+        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        switch (ia_type) {
+        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;
+}
+
+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);
 
-        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++) {
-                snprintf (key, sizeof (key), "%s.active%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
-        }
-        cli_out (" ");
+#endif
 
-        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++) {
-                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
 
-        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++) {
-                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 ("----------------------------------------------");
-
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                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);
 
-                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;
+        }
 
-                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);
 
-                        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);
-
-        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;
 
-        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;
 
-        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;
-
-        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)
-                        continue;
-
-                snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
-                          prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_refcount);
-                if (ret)
-                        continue;
+            continue;
 
-                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 ("----------------------------------------------");
-
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                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);
 
-                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;
+        }
 
-                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);
 
-                        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;
 
-        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;
 
-        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;
 
-        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"));
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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;
-
-        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;
 
-        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;
 
-        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;
 
-        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;
 
-        /*
-        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;
+    */
 
-        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);
 
-                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;
-
-        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;
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
+            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);
 
-                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;
+        }
 
-                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);
 
-                        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[64]     = {0,};
-        char            task[32]    = {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++) {
-                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);
 
-                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);
 
-                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")) {
-                        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++) {
-                                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_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;
-        }
-
-        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;
-
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        continue;
-
-                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 {
-                        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);
-                }
 
-                snprintf (key, sizeof (key), "brick%d.port", i);
-                ret = dict_get_int32 (dict, key, &(status.port));
-                if (ret)
-                        continue;
-
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &(status.online));
-                if (ret)
-                        continue;
+        /* Allocatated memory using gf_asprintf*/
+        GF_FREE(status.pid_str);
+    }
+    cli_out(" ");
 
-                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;
 
-                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;
-
-        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;
-}
+            goto out;
 
-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);
-
-        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);
+            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, "%d-path", brick);
-        ret = dict_get_str (dict, key, &path);
+            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;
-        cli_out ("\nBrick %s:%s", hostname, path);
+            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-status", brick);
-        ret = dict_get_str (dict, key, &status);
-        if (status && strlen (status))
-                cli_out ("Status: %s", 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);
 
-        snprintf (key, sizeof key, "%d-shd-status",brick);
-        ret = dict_get_str (dict, key, &shd_status);
+        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);
+    }
 
-        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);
+out:
+    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;
+}
 
-        }
+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)
+            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 4 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:
-        case    GF_SHD_OP_HEAL_SUMMARY:
-                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);
+    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_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;
+    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_statedump_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_STATEDUMP_VOLUME, this, cli_rpc_prog,
-                               NULL);
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    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);
 
-        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++) {
-                        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;
-
-        GF_ASSERT (myframe);
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        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();
 
-                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,
-                                "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;
-        }
+            }
+            cli_out("snap-max-soft-limit : %" PRIu64 "%%", soft_limit);
 
-        ret = dict_get_str (dict, "volname", &volname);
-        /* Ignore the error, as volname is optional */
-
-        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 ("auto-delete : %s", auto_delete);
-
-                cli_out ("activate-on-create : %s\n", snap_activate);
-
-                cli_out ("Snapshot Volume Configuration:");
+                cli_out("snap-max-hard-limit : %" PRIu64, value);
 
-                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
@@ -9748,2433 +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;
-        }
-        ret = dict_get_int32 (dict, key, &brickcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
-                goto out;
+            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;
-        }
+            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);
 
-        for (i = 0 ; i < volcount ; i++) {
-                ret = snprintf (key, sizeof (key), "%s.vol%d", keyprefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                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_dynstr_with_alloc (snap_dict, "cmd-str",
-                                       "snapshot status");
+    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;
+    }
+
+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");
+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 (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;
+            if (!volname) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
                 goto 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 (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 ((status_cmd != GF_SNAP_STATUS_TYPE_SNAP) &&
-            (status_cmd != GF_SNAP_STATUS_TYPE_ITER)) {
-                dict_copy (dict, local->dict);
+            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);
 
-        ret = snprintf (key, sizeof (key), "status.snap0");
-        if (ret < 0) {
-                goto out;
-        }
+            ret = 0;
+            break;
 
-        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;
-                }
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-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 (!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;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
 
-        if (snap_name) {
-                ret = dict_get_str (dict, "snapname", snap_name);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get snapname from dict");
-                }
+    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");
         }
+    }
 
-        if (volname) {
-                ret = dict_get_str (dict, "volname1", volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get volname1 from dict");
-                }
+    if (volname) {
+        ret = dict_get_str_sizen(dict, "volname1", volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get volname1 from dict");
         }
+    }
 
-        if (snap_uuid) {
-                ret = dict_get_str (dict, "snapuuid", snap_uuid);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get snapuuid from dict");
-                }
+    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");
         }
+    }
 
-        if (soft_limit_flag) {
-                ret = dict_get_int8 (dict, "soft-limit-reach",
-                                     soft_limit_flag);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get soft-limit-reach from dict");
-                }
+    if (soft_limit_flag) {
+        ret = dict_get_int8(dict, "soft-limit-reach", soft_limit_flag);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG,
+                   "failed to get soft-limit-reach from dict");
         }
+    }
 
-        if (clone_name) {
-                ret = dict_get_str (dict, "clonename", clone_name);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get clonename from dict");
-                }
+    if (clone_name) {
+        ret = dict_get_str_sizen(dict, "clonename", clone_name);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get clonename from dict");
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    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;
-        }
-
-        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;
-        }
-
-        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_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 (ret)
-                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;
+    }
+#endif
 
-        ret = dict_get_int32 (dict, "type", &type);
+    /* 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 (frame->this->name, GF_LOG_ERROR, "failed to get type");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
         }
 
-        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;
-        }
+        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");
+    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;
-        }
-#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");
-                }
+            }
 
+            if (!snap_name) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
                 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 (!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 (!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;
-        }
-
-        if (snapcount == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
-                cli_out ("No snapshots present");
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not populate snap request dictionary");
+            goto out;
         }
 
-        for (i = 0 ; i < snapcount; i++) {
-                ret = -1;
-
-                snap_dict = dict_new();
-                if (!snap_dict)
-                        goto out;
-
-                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);
 
-                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.
-                 */
-                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;
+        /* 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;
-
-        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:
-        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;
-
-        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_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);
+    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);
 
-        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);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, 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);
-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;
 }
 
-int
-add_cli_cmd_timeout_to_dict (dict_t *dict)
+static int
+add_cli_cmd_timeout_to_dict(dict_t *dict)
 {
-        int      ret     = 0;
+    int ret = 0;
 
-        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");
-                }
+    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;
+    }
+    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
+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 (!frame->local) {
-                ret = -1;
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !dict) {
+        ret = -1;
+        goto out;
+    }
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local->words) {
-                ret = -1;
-                goto out;
-        }
+    if (!local->words) {
+        ret = -1;
+        goto out;
+    }
 
-        words = local->words;
+    words = local->words;
 
-        while (words[i])
-                len += strlen (words[i++]) + 1;
+    while (words[i])
+        len += strlen(words[i++]) + 1;
 
-        cmd = GF_CALLOC (1, len, gf_common_mt_char);
+    cmd = GF_MALLOC(len + 1, gf_common_mt_char);
+    if (!cmd) {
+        ret = -1;
+        goto out;
+    }
+    cmd[0] = '\0';
 
-        if (!cmd) {
-                ret = -1;
-                goto out;
-        }
+    for (i = 0; words[i]; i++) {
+        strncat(cmd, words[i], len - 1);
+        if (words[i + 1] != NULL)
+            strncat(cmd, " ", len - 1);
+    }
 
-        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_sizen(dict, "cmd-str", cmd);
+    if (ret)
+        goto out;
 
-        cmd [len - 1] = '\0';
+    ret = add_cli_cmd_timeout_to_dict(dict);
 
-        ret = dict_set_dynstr (dict, "cmd-str", cmd);
-        if (ret)
-                goto out;
-
-        ret = add_cli_cmd_timeout_to_dict (dict);
+    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 < 0) {
+        gf_log(this->name, GF_LOG_DEBUG,
+               "failed to get serialized length of dict");
+        goto out;
+    }
 
-        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);
+    ret = cli_cmd_submit(NULL, req, frame, prog, procnum, iobref, this, cbkfn,
+                         (xdrproc_t)xdrproc);
 out:
-        return ret;
-
+    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);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get bitrot log file "
-                        "location");
-
-        ret = dict_get_str (dict, "scrub_log_file", &scrub_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 scrubber log file "
-                        "location");
+            gf_log("cli", GF_LOG_TRACE, "failed to get scrubbed files");
+        if (scrub_running)
+            break;
+    }
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not get count value from"
-                        " dictionary");
-                goto out;
-        }
+    if (scrub_running)
+        gf_asprintf(&scrub_state_op, "%s (In Progress)", state_scrub);
+    else
+        gf_asprintf(&scrub_state_op, "%s (Idle)", state_scrub);
 
-        for (i = 1; i <= count; i++) {
-                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("\n%s: %s\n", "Volume name ", volname);
 
-        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", "State of scrub", scrub_state_op);
 
-        cli_out ("\n%s: %s\n", "Volume name ", volname);
+    cli_out("%s: %s\n", "Scrub impact", scrub_impact);
 
-        cli_out ("%s: %s\n", "State of scrub", scrub_state_op);
+    cli_out("%s: %s\n", "Scrub frequency", scrub_freq);
 
-        cli_out ("%s: %s\n", "Scrub impact", scrub_impact);
+    cli_out("%s: %s\n", "Bitrot error log location", bitrot_log_file);
 
-        cli_out ("%s: %s\n", "Scrub frequency", scrub_freq);
+    cli_out("%s: %s\n", "Scrubber error log location", scrub_log_file);
 
-        cli_out ("%s: %s\n", "Bitrot error log location", bitrot_log_file);
+    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", "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");
 
-                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");
 
-                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");
 
-                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",
+                "=========================================================");
 
-                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);
 
-                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");
-                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++) {
-                                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;
-        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;
-        }
+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 ();
-
-                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) {
-                        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_sizen(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get command type");
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "type", &type);
+    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 get command type");
-                goto out;
+            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 (dict, "scrub-value", &scrub_cmd);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "Failed to get scrub command");
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get volume name");
+    /* 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 (dict, "cmd-str", &cmd_str);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get command string");
+    ret = dict_get_str_sizen(dict, "scrub-value", &scrub_cmd);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "Failed to get scrub command");
 
-        if (cmd_str)
-                cmd_op = strrchr(cmd_str, ' ') + 1;
+    ret = dict_get_str_sizen(dict, "cmd-str", &cmd_str);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get command string");
 
-        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 (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;
+    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;
+            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;
+            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, strlen("pause")))
-                        cli_out("volume bitrot: scrubber paused "
-                                "for volume %s", volname);
-                if (!strncmp ("resume", scrub_cmd, strlen("resume")))
-                        cli_out("volume bitrot: scrubber resumed "
-                                "for volume %s", volname);
-                ret = 0;
-                goto out;
+            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;
+            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;
-        }
+            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 4f912f81043..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:
@@ -47,4335 +44,3791 @@ enum gf_task_types {
  *  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);
-
-        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");
-                }
-                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);
-
-        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);
-        }
-        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;
-        }
+    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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
 
-        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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
 
-        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);
 
-        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);
 
-        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++) {
-                        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);
 
-        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++) {
-                        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);
 
-        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++) {
-                        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);
-
-                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;
 
-        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;
 
-        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;
 
-        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);
+        /* <fd> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fd");
+        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)
-                        continue;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"entry", "%d",
+                                              i + 1);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                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 *)"pid", "%d",
+                                              fd_pid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                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 *)"refCount",
+                                              "%d", fd_refcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </fdTable> */
-        ret = xmlTextWriterEndElement (writer);
-        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);
-
-                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);
-
-        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);
-        }
+    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);
+    }
 
-        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);
+    }
 
-        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);
+    }
 
-        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);
+    }
 
-        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);
-
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_get_int32 (dict, key, &gid);
+    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 *)"gid",
-                                               "%d", gid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto 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;
-        }
-
-        /* </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++) {
-                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++) {
-                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);
-        if (ret)
-                goto out;
+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);
 
-        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;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"type",
+                                              "%s", task_type);
+        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;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"type",
-                                                       "%s", task_type);
-                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);
 
-                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);
+        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);
 
-                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);
-
-                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;
-                }
+        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);
-
-        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 *)&time_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 *)&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);
-
-        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);
-        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);
+    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);
 
-        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 *)"name", "%s",
+                                              brick_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "1-top-op", &top_op);
+        snprintf(key, sizeof(key), "%d-members", i);
+        ret = dict_get_int32(dict, key, &members);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"topOp",
-                                               "%d", top_op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        while (i < brick_count) {
-                i++;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"members",
+                                              "%d", members);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <brick> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                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);
 
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick_name);
+                snprintf(key, sizeof(key), "%d-max-open", i);
+                ret = dict_get_uint64(dict, key, &max_open);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", brick_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"maxOpen", "%" PRIu64, max_open);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key , sizeof (key), "%d-members", i);
-                ret = dict_get_int32 (dict, key, &members);
+                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 *)"members",
-                                                       "%d", members);
-                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);
-
-                        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);
-
-                        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:
-                        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);
-                        }
-
-                        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;
+                    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:
+                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);
-
-                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);
-
-                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++) {
-                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);
 
-                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);
 
-                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);
 
-                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);
 
-                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);
 
-        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);
 
-        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);
 
-        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;
-                        }
-
-                        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);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+    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;
-
-        /* <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 = 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;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"name",
+                                              "%s", volname);
+        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.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.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.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);
 
-                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);
+        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.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.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.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.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);
+        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.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.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.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.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.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);
 
-                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);
-
-#ifdef HAVE_BD_XLATOR
-                /* <xlators> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"xlators");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (k = 0; ; k++) {
-                        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++) {
-                                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++) {
-
-                                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);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, index);
-                                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);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, index);
-                                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);
-
-                                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);
-
-                                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);
-
-                                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);
-
-                                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);
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"type",
+                                              "%d", type);
+        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;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"typeStr", "%s", vol_type_str[type]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (local->writer);
-                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);
 
-        if (volname) {
-                GF_FREE (local->get_vol.volname);
-                local->get_vol.volname = gf_strdup (volname);
-                local->vol_count += count;
+            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);
+
+            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);
+
+            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);
+
+        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;
-
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        if (ret)
-                goto out;
+    int ret = -1;
 
-        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++) {
-                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);
-
-                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);
+            goto out;
 
-                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);
-
-                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);
-                }
+        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);
+        }
 
-                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);
 
-                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);
+        }
 
-                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
-                 */
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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);
-
-                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;
 
-                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);
+        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);
 
-                total_skipped += skipped;
+        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);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"skipped",
-                                               "%"PRIu64, skipped);
-                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);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status_rcd);
-                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 *)"statusStr",
-                                                       "%s",
-                                         cli_vol_task_status_str[status_rcd]);
-                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;
 
-                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);
+        snprintf(key, sizeof(key), "skipped-%d", i);
 
-                if (elapsed > overall_elapsed) {
-                    overall_elapsed = elapsed;
-                }
+        ret = dict_get_uint64(dict, key, &skipped);
+        if (ret)
+            goto 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);
+        if (task_type == GF_TASK_TYPE_REMOVE_BRICK) {
+            failures += skipped;
+            skipped = 0;
         }
 
-        /* Aggregate status */
-        /* <aggregate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"aggregate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"files",
-                                               "%"PRIu64, total_files);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"size",
-                                               "%"PRIu64, total_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"lookups",
-                                               "%"PRIu64, total_lookups);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"failures",
-                                               "%"PRIu64, total_failures);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"skipped",
-                                               "%"PRIu64, total_skipped);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"status",
-                                               "%d", overall_status);
-        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 *)"statusStr",
-                                               "%s",
-                                      cli_vol_task_status_str[overall_status]);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        total_skipped += skipped;
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"runtime",
-                                               "%.2f", overall_elapsed);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"skipped",
+                                              "%" PRIu64, skipped);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </aggregate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                              status_rcd);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"statusStr", "%s",
+            cli_vol_task_status_str[status_rcd]);
+        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;
+        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);
 
+        if (elapsed > overall_elapsed) {
+            overall_elapsed = elapsed;
+        }
 
-        GF_VALIDATE_OR_GOTO ("cli", dict, 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
+         */
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto 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 = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nodeCount",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* Aggregate status */
+    /* <aggregate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"aggregate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        while (i <= count) {
-                promoted = 0;
-                node_name = NULL;
-                demoted = 0;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"files",
+                                          "%" PRIu64, total_files);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size", "%" PRIu64,
+                                          total_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                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);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lookups",
+                                          "%" PRIu64, total_lookups);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                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);
-
-                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);
 
-                snprintf (key, sizeof (key), "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;
-        }
+            goto out;
+    }
 
-        /* </volRebalance> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, 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;
+            goto out;
+    }
 
-        ret = xmlTextWriterStartElement (writer, (xmlChar *) op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(writer);
+    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);
-        }
-
-        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 = 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;
-        }
+    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 (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 = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"session_slave", "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
+
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"pair");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        for (j = 0; j < number_of_fields; j++) {
+            /* XML ignore fields */
+            if (strcmp(title_values[j], "") == 0)
+                continue;
 
-                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;
-                        }
+            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);
+        }
 
-                        if (strcmp (volume, volume_next)!=0) {
-                                closed = 1;
-                                session_closed = 1;
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                                ret = xmlTextWriterEndElement (writer);
-                                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 = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
+            if (strcmp(volume, volume_next) != 0) {
+                closed = 1;
+                session_closed = 1;
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        } else if (strcmp (slave, slave_next)!=0) {
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                                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);
+            } 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);
 
-                        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
 }
 
@@ -4389,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.
@@ -4448,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
@@ -4508,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.
@@ -4597,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
@@ -4661,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.
@@ -4735,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);
+    /* </snapVolume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, 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) {
-                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
@@ -4810,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);
-        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);
+    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 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.
@@ -4927,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 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 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
@@ -5007,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);
+
+        ret = snprintf(key, sizeof(key), "%s.brick%d.path", keyprefix, i);
+        if (ret < 0)
+            goto out;
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-        GF_ASSERT (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);
 
-        snprintf (key, sizeof (key), "%s.brickcount", keyprefix);
+        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);
+
+        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);
 
-                /* </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.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
@@ -5152,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.
@@ -5244,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.
@@ -5313,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);
+    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-hard-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-hard-limit");
-                goto out;
+            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);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              str_value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &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, "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 = 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 = 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.
@@ -5471,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.
@@ -5563,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
@@ -5627,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 */
 
@@ -5701,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
@@ -5898,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 025f72c9748..a52b39c5fb8 100644
--- a/cli/src/cli.c
+++ b/cli/src/cli.c
@@ -33,279 +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 "gf-event.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 (ctx, (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;
+        }
+
+        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;
+    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;
-
-        this = mydata;
+    xlator_t *this = NULL;
+    int ret = 0;
 
-        switch (event) {
-        case RPC_CLNT_CONNECT:
-        {
+    this = mydata;
 
-                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;
 }
 
 /*
@@ -315,527 +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 ("invalid 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;
-                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"))
-                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;
-                        }
-                }
+            }
+        } else {
+            cli_err("invalid secure-mgmt value (ignored)");
         }
+        return 0;
+    }
 
-        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);
 
-        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;
+    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";
+    char *addr_family = "inet6";
 #else
-        char                    *addr_family = "inet";
+    char *addr_family = "inet";
 #endif
 
-        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;
-
-                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 3421d6911fb..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, int32_t *command);
+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 54b52a35f8c..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,16 +21,13 @@ 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
-
 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
@@ -47,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
@@ -64,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
@@ -86,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
@@ -124,20 +110,10 @@ AC_CONFIG_FILES([Makefile
                 xlators/features/arbiter/src/Makefile
                 xlators/features/thin-arbiter/Makefile
                 xlators/features/thin-arbiter/src/Makefile
-                xlators/experimental/fdl/Makefile
-                xlators/experimental/fdl/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
@@ -186,14 +162,13 @@ AC_CONFIG_FILES([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
@@ -203,23 +178,6 @@ AC_CONFIG_FILES([Makefile
                 xlators/mgmt/Makefile
                 xlators/mgmt/glusterd/Makefile
                 xlators/mgmt/glusterd/src/Makefile
-                xlators/experimental/Makefile
-                xlators/experimental/jbr-client/Makefile
-                xlators/experimental/jbr-client/src/Makefile
-                xlators/experimental/jbr-server/Makefile
-                xlators/experimental/jbr-server/src/Makefile
-                xlators/experimental/dht2/Makefile
-                xlators/experimental/dht2/dht2-client/Makefile
-                xlators/experimental/dht2/dht2-client/src/Makefile
-                xlators/experimental/dht2/dht2-server/Makefile
-                xlators/experimental/dht2/dht2-server/src/Makefile
-                xlators/experimental/posix2/Makefile
-                xlators/experimental/posix2/ds/Makefile
-                xlators/experimental/posix2/ds/src/Makefile
-                xlators/experimental/posix2/mds/Makefile
-                xlators/experimental/posix2/mds/src/Makefile
-                xlators/experimental/posix2/common/Makefile
-                xlators/experimental/posix2/common/src/Makefile
                 cli/Makefile
                 cli/src/Makefile
                 doc/Makefile
@@ -235,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
@@ -265,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
@@ -274,7 +238,6 @@ AC_CONFIG_FILES([Makefile
                 contrib/umountd/Makefile
                 glusterfs-api.pc
                 libgfchangelog.pc
-                libgfdb.pc
                 api/Makefile
                 api/src/Makefile
                 api/examples/Makefile
@@ -312,10 +275,78 @@ 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
 
 
@@ -345,13 +376,15 @@ AC_ARG_WITH([ipv6-default],
 
 AC_CHECK_FILE([/etc/centos-release])
 if test "x$ac_cv_file__etc_centos_release" = "xyes"; then
-        dnl On CentOS '-ldl' isn't automatically added to LIBS
-        AC_CHECK_LIB([dl], [dlopen])
         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.]))
@@ -369,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],
@@ -499,6 +547,8 @@ 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)
@@ -540,7 +590,7 @@ if test "x$have_uuid" != "xyes"; then
 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)
 
@@ -619,53 +669,54 @@ fi
 
 dnl Check Python Availability
 have_python=no
-case $host_os in
-  freebsd*)
-    PYTHON=/usr/local/bin/python2
-    ;;
-  *)
-    PYTHON=/usr/bin/python2
-    ;;
-esac
+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 "x${PYTHON}" != "x:"; then
+if test -n "${PYTHON}"; then
    have_python=yes
 fi
+AM_CONDITIONAL(HAVE_PYTHON, test "x$have_python" = "xyes")
 
-echo "python = ${PYTHON}"
-
-dnl Check if version matches that we require
-PYTHONDEV_CPPFLAGS=
-PYTHONDEV_LDFLAGS=
-BUILD_PYTHON_SITE_PACKAGES=
-BUILD_PYTHON_INC=
-BUILD_PYTHON_LIB=
-have_Python_h="no"
-
-dnl Use pkg-config to get runtime search patch missing from ${PYTHON}-config
+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
-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 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
 
-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`"
+PYTHON_CFLAGS=$(echo ${PYTHON_CFLAGS} | sed -e 's|-I|-isystem |')
 
 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],[])
-
-AC_SUBST(PYTHONDEV_CPPFLAGS)
-AC_SUBST(PYTHONDEV_LDFLAGS)
 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],
@@ -678,42 +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]))
+AC_SUBST(FUSE_CLIENT_SUBDIR)
 
-if test "x${with_server}" = "xyes" -a "x$enable_bd_xlator" != "xno"; then
-  AC_CHECK_LIB([lvm2app],
-               [lvm_init,lvm_lv_from_name],
-               [HAVE_BD_LIB="yes"],
-               [HAVE_BD_LIB="no"])
+AC_ARG_ENABLE([fuse-notifications],
+  AS_HELP_STRING([--disable-fuse-notifications], [Disable FUSE notifications]))
 
-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
+AS_IF([test "x$enable_fuse_notifications" != "xno"], [
+  AC_DEFINE([HAVE_FUSE_NOTIFICATIONS], [1], [Use FUSE notifications])
+])
 
-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
-
-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
+# end FUSE section
 
-AM_CONDITIONAL([ENABLE_BD_XLATOR], [test x$BUILD_BD_XLATOR = xyes])
 
 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
@@ -722,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],
@@ -774,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],
@@ -828,6 +785,9 @@ AC_ARG_ENABLE([georeplication],
 
 BUILD_SYNCDAEMON=no
 case $host_os in
+     freebsd*)
+#do nothing
+       ;;
      linux*)
 #do nothing
        ;;
@@ -867,6 +827,17 @@ 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],
@@ -930,33 +901,6 @@ 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${with_server}" = "xyes" -a "x${BUILD_GFDB}" = "xyes")
-AM_CONDITIONAL(USE_GFDB, test "x${with_server}" = "xyes" -a "x${BUILD_GFDB}" = "xyes")
-
 # xml-output
 AC_ARG_ENABLE([xml-output],
               AC_HELP_STRING([--disable-xml-output],
@@ -986,7 +930,7 @@ fi
 dnl cloudsync section
 BUILD_CLOUDSYNC="no"
 AC_CHECK_LIB([curl], [curl_easy_setopt], [LIBCURL="-lcurl"])
-if test "x$LIBCURL" != "x";then
+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"])
@@ -997,6 +941,17 @@ 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
 
@@ -1021,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);],
    [],
@@ -1028,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])
@@ -1040,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])
@@ -1059,6 +1033,9 @@ case $host_os in
     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]))
@@ -1109,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
@@ -1124,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=
@@ -1144,7 +1163,7 @@ 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
@@ -1179,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.
@@ -1244,7 +1256,6 @@ if test "x$exec_prefix" = xNONE; then
         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
 
@@ -1256,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
@@ -1264,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"
@@ -1285,7 +1299,7 @@ case $host_os in
         GF_FUSE_CFLAGS="-DFUSERMOUNT_DIR=\\\"\$(sbindir)\\\""
         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
@@ -1296,17 +1310,13 @@ case $host_os in
         ;;
      *freebsd*)
         GF_HOST_OS="GF_BSD_HOST_OS"
-        GF_CFLAGS="${GF_CFLAGS} -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_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
@@ -1321,21 +1331,13 @@ case $host_os in
         GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME"
         GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME"
         GF_LDADD="${ARGP_LDADD}"
-        GF_LDFLAGS=""
+        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
@@ -1353,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=""
@@ -1409,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
@@ -1422,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_python}" = "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${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
@@ -1483,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"
@@ -1523,18 +1486,6 @@ AC_SUBST(UNITTEST_LDFLAGS)
 AC_SUBST(CFLAGS)
 # end enable debug section
 
-# experimental section
-AC_ARG_ENABLE([experimental],
-              AC_HELP_STRING([--disable-experimental],
-                             [Disable building experimental xlators]))
-
-BUILD_EXPERIMENTAL="yes"
-if test "x$enable_experimental" = "xno"; then
-  BUILD_EXPERIMENTAL="no"
-fi
-AM_CONDITIONAL([ENABLE_EXPERIMENTAL], [test x$BUILD_EXPERIMENTAL = xyes])
-#end experimental section
-
 # EC dynamic code generation section
 
 EC_DYNAMIC_SUPPORT="none"
@@ -1638,7 +1589,10 @@ case $host_os in
     GF_NO_UNDEFINED=''
     ;;
 esac
-GF_XLATOR_DEFAULT_LDFLAGS='-avoid-version -export-symbols $(top_srcdir)/xlators/xlator.sym '${GF_NO_UNDEFINED}
+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)
@@ -1652,12 +1606,23 @@ 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])
 
@@ -1688,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"
@@ -1716,25 +1679,21 @@ echo
 echo "GlusterFS configure summary"
 echo "==========================="
 echo "FUSE client          : $BUILD_FUSE_CLIENT"
-echo "Infiniband verbs     : $BUILD_IBVERBS"
 echo "epoll IO multiplex   : $BUILD_EPOLL"
 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 "Experimental xlators : $BUILD_EXPERIMENTAL"
 echo "Events               : $BUILD_EVENTS"
 echo "EC dynamic support   : $EC_DYNAMIC_SUPPORT"
 echo "Use memory pools     : $USE_MEMPOOL"
@@ -1745,4 +1704,14 @@ 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/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 6380dd8678e..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;
 
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 ffa0a4b6316..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);
@@ -384,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/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/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 c06dd54db6e..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)
@@ -66,7 +66,7 @@ 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) {
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/doc/Makefile.am b/doc/Makefile.am
index 7c04d74019a..de68c20b4d7 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -1,9 +1,9 @@
 EXTRA_DIST = glusterfs.8 mount.glusterfs.8 gluster.8 \
 			glusterd.8 glusterfsd.8
 
-man8_MANS = glusterfs.8 mount.glusterfs.8
+man8_MANS = glusterfs.8 mount.glusterfs.8 gluster.8
 if WITH_SERVER
-man8_MANS += gluster.8 glusterd.8 glusterfsd.8
+man8_MANS += glusterd.8 glusterfsd.8
 endif
 
 CLEANFILES =
diff --git a/doc/README.md b/doc/README.md
index 6294df94b67..6aa28642ef4 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -1,3 +1,11 @@
+## 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://docs.gluster.org/en/latest/Administrator%20Guide/).
@@ -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://docs.gluster.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/debugging/analyzing-regression-cores.md b/doc/debugging/analyzing-regression-cores.md
index cbbb387794d..5e10f41c6eb 100644
--- a/doc/debugging/analyzing-regression-cores.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.
-~~~
+# 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.
-~~~
+```
+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.
-~~~
+```
 [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/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/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 33f2e58504c..951f5fae2f6 100644
--- a/doc/developer-guide/Language-Bindings.md
+++ b/doc/developer-guide/Language-Bindings.md
@@ -1,3 +1,4 @@
+# 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.
 
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 9bc15a5cc15..031c6c0da99 100644
--- a/doc/developer-guide/coding-standard.md
+++ b/doc/developer-guide/coding-standard.md
@@ -1,6 +1,30 @@
 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
 ------------------------------------------------------
 
@@ -342,6 +366,37 @@ 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
 -------------------------
 
@@ -565,8 +620,8 @@ If a value isn't supposed/expected to change, there's no cost to adding a
 
 ### 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,
+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
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/xlator-classification.md b/doc/developer-guide/xlator-classification.md
index 50d2bdc61e8..6073df9375f 100644
--- a/doc/developer-guide/xlator-classification.md
+++ b/doc/developer-guide/xlator-classification.md
@@ -23,7 +23,7 @@ This document is intended for the following community participants,
 - Existing xlator maintainers
 - Packaging and gluster management stack maintainers
 
-For a more user facing understanding it is recommended to read section [tbd](TBD)
+For a more user facing understanding it is recommended to read section (TBD)
 in the gluster documentation.
 
 ## Categories
@@ -130,7 +130,50 @@ These xlators and their corresponding code and test health will not be executed.
 
 ### How to specify an xlators category
 
-(TBD)
+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
 
diff --git a/doc/features/ctime.md b/doc/features/ctime.md
index 6c6cad90055..74a77abed4b 100644
--- a/doc/features/ctime.md
+++ b/doc/features/ctime.md
@@ -1,25 +1,25 @@
-#Consistent time attributes in gluster across replica/distribute
+# Consistent time attributes in gluster across replica/distribute
 
 
-####Problem:
+#### 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:
+#### 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:
+#### 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,
+  - 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.
+  -  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.
 
@@ -29,19 +29,19 @@ for ex: because of locks.
 
  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)
+  - 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:
+#### Implementation Overview:
 This features involves changes in following xlators.
-> - utime xlator
-> - posix xlator
+ - utime xlator
+ - posix xlator
 
-#####utime 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.
@@ -50,7 +50,7 @@ This is a new client side xlator which does following tasks.
     Patches:
     1. https://review.gluster.org/#/c/19857/
 
-#####posix xlator:
+##### 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.
@@ -61,7 +61,7 @@ Following tasks are done in posix xlator:
     2. https://review.gluster.org/#/c/19795/
     3. https://review.gluster.org/#/c/19796/
 
-####Pending Work:
+#### 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
diff --git a/doc/gluster.8 b/doc/gluster.8
index 3c523260c2d..ba595edca15 100644
--- a/doc/gluster.8
+++ b/doc/gluster.8
@@ -38,10 +38,10 @@ Display information about all volumes, or the specified volume.
 \fB\ volume list \fR
 List all volumes in cluster
 .TP
-\fB\ volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad|tierd]] [detail|clients|mem|inode|fd|callpool|tasks|client-list] \fR
+\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
@@ -113,6 +113,9 @@ Rotate the log file for corresponding volume/brick.
 \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
@@ -134,32 +137,6 @@ List all the nodes in the pool (including localhost)
 .TP
 \fB\ peer help \fR
 Display help for the peer command.
-.SS "Tier Commands"
-.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.
-.TP
-\fB\ volume tier <VOLNAME> start [force] \fR
-Start the tier service for <VOLNAME>
-.TP
-\fB\ volume tier <VOLNAME> status \fR
-Display statistics on data migration between the hot and cold tiers.
-.TP
-\fB\ volume tier <VOLNAME> stop [force] \fR
-Stop the tier service for <VOLNAME>
-.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.
-.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.
-.TP
-\fB\ volume tier <VOLNAME> detach status\fR
-Check status of data movement from the hot to cold tier.
-.TP
-\fB\ volume tier <VOLNAME> detach stop\fR
-Stop detaching the hot tier from the volume.
-
 .SS "Quota Commands"
 .TP
 \fB\ volume quota <VOLNAME> enable \fR
@@ -214,8 +191,10 @@ NOTE: valid units of time and their symbols are : hours(h/hr), minutes(m/min), s
 \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
@@ -239,6 +218,12 @@ 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
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 592dedb6759..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).
@@ -139,6 +139,11 @@ Enable fuse in-kernel writeback cache.
 \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 367f02d9b1a..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
@@ -122,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
@@ -142,6 +151,11 @@ 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/events/eventskeygen.py b/events/eventskeygen.py
index 4ccedea8f9e..e28ebe9b7e6 100644
--- a/events/eventskeygen.py
+++ b/events/eventskeygen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
diff --git a/events/src/Makefile.am b/events/src/Makefile.am
index 4e83a469cc2..3b229691897 100644
--- a/events/src/Makefile.am
+++ b/events/src/Makefile.am
@@ -5,7 +5,7 @@ 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
@@ -28,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 003cb981572..700093bee60 100644
--- a/events/src/eventsapiconf.py.in
+++ b/events/src/eventsapiconf.py.in
@@ -18,7 +18,8 @@ def get_glusterd_workdir():
     if glusterd_workdir is not None:
         return glusterd_workdir
     proc = subprocess.Popen(["gluster", "system::", "getwd"],
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                            universal_newlines = True)
     out, err = proc.communicate()
     if proc.returncode == 0:
         glusterd_workdir = out.strip()
@@ -27,6 +28,8 @@ def get_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 = get_glusterd_workdir() + CUSTOM_CONFIG_FILE_TO_SYNC
diff --git a/events/src/gf_event.py b/events/src/gf_event.py
index fd272434242..260b0d9aa48 100644
--- a/events/src/gf_event.py
+++ b/events/src/gf_event.py
@@ -1,4 +1,3 @@
-#!/usr/bin/python2
 # -*- 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 b61d1a1b28b..341a3b60947 100644
--- a/events/src/glustereventsd.py
+++ b/events/src/glustereventsd.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -13,6 +13,7 @@
 from __future__ import print_function
 import sys
 import signal
+import threading
 try:
     import socketserver
 except ImportError:
@@ -23,15 +24,25 @@ 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:
@@ -86,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()
@@ -96,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 fb11e12deb4..4d2e5f35b1c 100644
--- a/events/src/peer_eventsapi.py
+++ b/events/src/peer_eventsapi.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/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 0ec7051ec28..6d4e0791a2b 100644
--- a/events/src/utils.py
+++ b/events/src/utils.py
@@ -9,9 +9,11 @@
 #  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
@@ -26,13 +28,15 @@ 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
@@ -95,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] "
@@ -387,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:
diff --git a/events/tools/eventsdash.py b/events/tools/eventsdash.py
index 4346c834ee4..6479ea59da6 100644
--- a/events/tools/eventsdash.py
+++ b/events/tools/eventsdash.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
diff --git a/extras/Makefile.am b/extras/Makefile.am
index a1c657659f3..983f014cca6 100644
--- a/extras/Makefile.am
+++ b/extras/Makefile.am
@@ -11,23 +11,25 @@ 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 \
-	    group-db-workload
+	    group-db-workload group-distributed-virt group-samba
 endif
 
 voldir = $(sysconfdir)/glusterfs
+vol_DATA = thin-arbiter/thin-arbiter.vol
 if WITH_SERVER
-vol_DATA = glusterd.vol
+vol_DATA += glusterd.vol
 endif
 
 scriptsdir = $(datadir)/glusterfs/scripts
-scripts_SCRIPTS =
+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
@@ -40,14 +42,15 @@ endif
 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 specgen.scm glusterfs-mode.el glusterfs.vim \
+	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
+	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:
@@ -67,4 +70,8 @@ install-data-local:
 		$(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 2e0ffe772c7..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/python2
+    #!/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/python2
+    #!/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/control-cpu-load.sh b/extras/control-cpu-load.sh
index b739c821055..52dcf62fd9f 100755
--- a/extras/control-cpu-load.sh
+++ b/extras/control-cpu-load.sh
@@ -104,7 +104,7 @@ 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 gluster | awk -F " " '{print $2}'`;
+  for thid in `ps -T -p ${daemon_pid} | grep -v SPID | awk -F " " '{print $2}'`;
     do
       echo ${thid} > ${LOC}/${cgroup_name}/tasks ;
     done
diff --git a/extras/control-mem.sh b/extras/control-mem.sh
index 38aa2a08748..91b36f8107a 100755
--- a/extras/control-mem.sh
+++ b/extras/control-mem.sh
@@ -116,7 +116,7 @@ else
 fi
 
 if ps -T -p ${daemon_pid} | grep gluster > /dev/null; then
-  for thid in `ps -T -p ${daemon_pid} | grep gluster | awk -F " " '{print $2}'`;
+  for thid in `ps -T -p ${daemon_pid} | grep -v SPID | awk -F " " '{print $2}'`;
     do
       echo ${thid} > ${LOC}/${cgroup_name}/tasks ;
     done
diff --git a/extras/create_new_xlator/generate_xlator.py b/extras/create_new_xlator/generate_xlator.py
index 2746e90893d..983868c04db 100755
--- a/extras/create_new_xlator/generate_xlator.py
+++ b/extras/create_new_xlator/generate_xlator.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
 import os
@@ -113,7 +113,7 @@ def gen_xlator():
 
         xlator_methods = fragments["XLATOR_METHODS"].replace("@XL_NAME@", xl_name)
         xlator_methods = xlator_methods.replace("@FOP_PREFIX@", fop_prefix)
-	print(xlator_methods, file=xl)
+        print(xlator_methods, file=xl)
 
         xl.close()
 
@@ -169,7 +169,7 @@ def load_fragments ():
         cur_value = ""
         result = {}
         basepath = os.path.abspath(os.path.dirname(__file__))
-        fragpath = basepath + "/new-xlator-tmpl.c"
+        fragpath = basepath + "/new-xlator.c.tmpl"
         for line in open(fragpath, "r").readlines():
                 m = pragma_re.search(line)
                 if m:
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 1f2f9c316a2..00000000000
--- a/extras/create_new_xlator/new-xlator-tmpl.c
+++ /dev/null
@@ -1,164 +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 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 = ""
-        },
-        { .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@",
-};
-#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.h"
-#include "xlator.h"
-#include "defaults.h"
-
-#endif /* __@HFL_NAME@_H__ */
-
-#pragma fragment MEM_HEADER_FMT
-#ifndef __@HFL_NAME@_H__
-#define __@HFL_NAME@_H__
-
-#include "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 "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/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 72b93c1353f..33fbae288bc 100755
--- a/extras/devel-tools/print-backtrace.sh
+++ b/extras/devel-tools/print-backtrace.sh
@@ -40,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
@@ -50,9 +52,11 @@ 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:]]*//')
@@ -92,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/distributed-test-env b/extras/distributed-testing/distributed-test-env
index 0d57d5237dd..36fdd82e5dd 100644
--- a/extras/distributed-testing/distributed-test-env
+++ b/extras/distributed-testing/distributed-test-env
@@ -32,7 +32,6 @@ BROKEN_TESTS="\
   tests/bugs/gfapi/bug-1093594.t\
   tests/bugs/replicate/bug-1473026.t\
   tests/bugs/replicate/bug-802417.t\
-  tests/encryption/crypt.t\
   tests/basic/inode-leak.t\
   tests/basic/distribute/force-migration.t\
   tests/basic/ec/heal-info.t\
diff --git a/extras/distributed-testing/distributed-test-runner.py b/extras/distributed-testing/distributed-test-runner.py
index 4d6313625db..5a07e2feab1 100755
--- a/extras/distributed-testing/distributed-test-runner.py
+++ b/extras/distributed-testing/distributed-test-runner.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import absolute_import
 from __future__ import division
@@ -383,14 +383,17 @@ class Handlers:
         return self.shell.call("make install") == 0
 
     @synchronized
-    def prove(self, id, test, timeout, valgrind=False, asan_noleaks=True):
+    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:
+        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 "
@@ -827,8 +830,9 @@ 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", help="run tests under valgrind",
-                    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",
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 0f5ad38aa09..f7f110246b5 100755
--- a/extras/failed-tests.py
+++ b/extras/failed-tests.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
 import blessings
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 38d8f500ad6..48b2b507060 100644
--- a/extras/geo-rep/schedule_georep.py.in
+++ b/extras/geo-rep/schedule_georep.py.in
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 """
 Schedule Geo-replication
 ------------------------
@@ -83,7 +83,7 @@ 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:
@@ -352,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])
@@ -459,8 +459,8 @@ if __name__ == "__main__":
                             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. "
diff --git a/extras/glusterd.vol.in b/extras/glusterd.vol.in
index fe413a9b4ab..5d7bad0e4c8 100644
--- a/extras/glusterd.vol.in
+++ b/extras/glusterd.vol.in
@@ -1,14 +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  65535
+    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 6341d007188..6341d007188 100644..100755
--- a/extras/gnfs-loganalyse.py
+++ b/extras/gnfs-loganalyse.py
diff --git a/extras/group-db-workload b/extras/group-db-workload
index c9caf218268..9334d6fb942 100644
--- a/extras/group-db-workload
+++ b/extras/group-db-workload
@@ -1,4 +1,4 @@
-performance.open-behind=off
+performance.open-behind=on
 performance.write-behind=off
 performance.stat-prefetch=off
 performance.quick-read=off
@@ -6,3 +6,7 @@ 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 56b406e3641..1e398019e6b 100644
--- a/extras/group-gluster-block
+++ b/extras/group-gluster-block
@@ -5,6 +5,14 @@ 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=enable
 cluster.quorum-type=auto
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 7e34b7297be..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
@@ -13,3 +14,11 @@ 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 48ee1c788b6..2c79eb1d54a 100755
--- a/extras/hook-scripts/S40ufo-stop.py
+++ b/extras/hook-scripts/S40ufo-stop.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/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 d8707a8fb4d..7d6052315bb 100755
--- a/extras/hook-scripts/S56glusterd-geo-rep-create-post.sh
+++ b/extras/hook-scripts/S56glusterd-geo-rep-create-post.sh
@@ -92,11 +92,13 @@ if [ -f $pub_file ]; then
             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 bfc0c1cf080..9b236df096d 100644
--- a/extras/hook-scripts/add-brick/post/Makefile.am
+++ b/extras/hook-scripts/add-brick/post/Makefile.am
@@ -1,6 +1,6 @@
-EXTRA_DIST = disabled-quota-root-xattr-heal.sh S13create-subdir-mounts.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/
 if WITH_SERVER
-hook_SCRIPTS = disabled-quota-root-xattr-heal.sh S13create-subdir-mounts.sh
+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/create/post/S10selinux-label-brick.sh b/extras/hook-scripts/create/post/S10selinux-label-brick.sh
index de242d20af4..f9b4b1a57e3 100755
--- a/extras/hook-scripts/create/post/S10selinux-label-brick.sh
+++ b/extras/hook-scripts/create/post/S10selinux-label-brick.sh
@@ -34,18 +34,21 @@ parse_args () {
 
 set_brick_labels()
 {
-  volname=${1}
+  volname="${1}"
 
   # grab the path for each local brick
-  brickpath="/var/lib/glusterd/vols/${volname}/bricks/*"
-  brickdirs=$(grep '^path=' "${brickpath}" | cut -d= -f 2 | sort -u)
+  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
     # Add a file context for each brick path and associate with the
     # glusterd_brick_t SELinux type.
-    pattern="${b}\(/.*\)?"
+    pattern="${b}(/.*)?"
     semanage fcontext --add -t glusterd_brick_t -r s0 "${pattern}"
-
     # Set the labels on the new brick path.
     restorecon -R "${b}"
   done
diff --git a/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh b/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh
index 6eba66fbe07..056b52afe76 100755
--- a/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh
+++ b/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh
@@ -15,45 +15,59 @@ OPTSPEC="volname:"
 VOL=
 
 function parse_args () {
-        ARGS=$(getopt -o '' -l $OPTSPEC -n $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
+[ -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/S30samba-set.sh b/extras/hook-scripts/set/post/S30samba-set.sh
index c596db02381..854f131f6c8 100755
--- a/extras/hook-scripts/set/post/S30samba-set.sh
+++ b/extras/hook-scripts/set/post/S30samba-set.sh
@@ -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}
 }
 
@@ -123,9 +123,18 @@ 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"
 }
 
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 885ed03ad5b..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;
@@ -120,10 +127,10 @@ if [ "$option" == "enable" ]; then
         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 e32546dc999..792019d3c9f 100644
--- a/extras/hook-scripts/start/post/Makefile.am
+++ b/extras/hook-scripts/start/post/Makefile.am
@@ -1,4 +1,4 @@
-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
diff --git a/extras/hook-scripts/start/post/S30samba-start.sh b/extras/hook-scripts/start/post/S30samba-start.sh
index 5d586ee9fae..cac0cbf1464 100755
--- a/extras/hook-scripts/start/post/S30samba-start.sh
+++ b/extras/hook-scripts/start/post/S30samba-start.sh
@@ -68,14 +68,14 @@ function parse_args () {
 }
 
 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 () {
@@ -88,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";
@@ -106,28 +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
+
+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
+if ! grep --quiet "\[gluster-$VOL\]" "${CONFIGFILE}" ; then
+        add_samba_share "$VOL"
 else
-        sed -i '/\[gluster-'"$VOL"'\]/,/^$/!b;/available = no/d' ${CONFIGFILE}
+        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/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 25f9145f120..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 =
 
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 e99233f7e1e..cc40e13c3e3 100755
--- a/extras/mount-shared-storage.sh
+++ b/extras/mount-shared-storage.sh
@@ -21,7 +21,7 @@ do
 			continue
 		fi
 
-		mount -t glusterfs "${arr[0]}" "${arr[1]}"
+		mount -t glusterfs -o "${arr[3]}" "${arr[0]}" "${arr[1]}"
 		#wait for few seconds
 		sleep 10
 
diff --git a/extras/ocf/volume.in b/extras/ocf/volume.in
index 46dd20b8ced..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,6 +77,10 @@ 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="@GLUSTERD_WORKDIR@/vols/${OCF_RESKEY_volname}"
@@ -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 5f5e4ed8dbd..aaafd088648 100755
--- a/extras/profiler/glusterfs-profiler
+++ b/extras/profiler/glusterfs-profiler
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 #  Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com>
 #  This file is part of GlusterFS.
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 2a66079de12..3ad9513f40e 100644
--- a/xlators/features/glupy/src/__init__.py.in
+++ b/extras/python/__init__.py
@@ -1,4 +1,2 @@
-#!/usr/bin/python2
-
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
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
index 2803c6ec7c6..e62f7fc52a3 100755
--- a/extras/quota/quota_fsck.py
+++ b/extras/quota/quota_fsck.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # The following script enables, Detecting, Reporting and Fixing
 # anomalies in quota accounting. Run this script with -h option
 # for further details.
@@ -52,17 +52,17 @@ epilog_msg='''
 
 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})
+        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})
+        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['contri_size'],
-                   dir_size})
+            print('%24s %60s %12s %12s' % ("Size Mismatch", path,
+                xattr_dict, dir_size))
         else:
-            print('%-24s %-60s %-12i %-12i' % {"Size Mismatch", path, xattr_dict['contri_size'],
-                   stbuf.st_size})
+            print('%-24s %-60s %-12s %-12s' % ("Size Mismatch", path, xattr_dict,
+                   stbuf.st_size))
 
 def size_differs_lot(s1, s2):
     '''
@@ -156,12 +156,10 @@ def get_quota_xattr_brick(dpath):
     xattr_dict = {}
     xattr_dict['parents'] = {}
 
-    for xattr in pairs:
+    for xattr in pairs[1:]:
+        xattr = xattr.decode("utf-8")
         xattr_key = xattr.split("=")[0]
-        if re.search("# file:", xattr_key):
-            # skip the file comment
-            continue
-        elif xattr_key is "":
+        if xattr_key == "":
             # skip any empty lines
             continue
         elif not re.search("quota", xattr_key):
diff --git a/extras/quota/xattr_analysis.py b/extras/quota/xattr_analysis.py
index 780ff340677..7bd7d96374c 100755
--- a/extras/quota/xattr_analysis.py
+++ b/extras/quota/xattr_analysis.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/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.
diff --git a/extras/rebalance.py b/extras/rebalance.py
index 6dd364b9028..37c68ebbb42 100755
--- a/extras/rebalance.py
+++ b/extras/rebalance.py
@@ -1,6 +1,7 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
+
 import atexit
 import copy
 import optparse
@@ -155,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")
@@ -166,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]
diff --git a/extras/snap_scheduler/conf.py.in b/extras/snap_scheduler/conf.py.in
index e04b6cb008b..6dcca0534a7 100644
--- a/extras/snap_scheduler/conf.py.in
+++ b/extras/snap_scheduler/conf.py.in
@@ -1,4 +1,3 @@
-#!/usr/bin/python2
 #
 # Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
diff --git a/extras/snap_scheduler/gcron.py b/extras/snap_scheduler/gcron.py
index de79562ceab..0e4df77d481 100755
--- a/extras/snap_scheduler/gcron.py
+++ b/extras/snap_scheduler/gcron.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/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")
@@ -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 (OSError, IOError) as (errno, strerror):
+        except (OSError, IOError):
             log.info("Job %s is being processed by another agent", name)
         os.close(f)
-    except (OSError, 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
 
@@ -130,12 +131,12 @@ def main():
                 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):
@@ -154,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:
@@ -168,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 f0868d8b57d..e8fcc449a9b 100755
--- a/extras/snap_scheduler/snap_scheduler.py
+++ b/extras/snap_scheduler/snap_scheduler.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/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)
@@ -209,9 +209,9 @@ def enable_scheduler():
                     f = os.open(GCRON_ENABLED, os.O_CREAT | os.O_NONBLOCK,
                                 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
@@ -268,8 +269,9 @@ def disable_scheduler():
                 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
@@ -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
 
@@ -393,8 +395,8 @@ def update_current_scheduler(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
 
@@ -459,9 +461,9 @@ def add_schedules(jobname, schedule, volname):
                         f = os.open(job_lockfile, os.O_CREAT | os.O_NONBLOCK,
                                     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"
@@ -650,8 +652,8 @@ def initialise_scheduler():
             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
 
@@ -661,8 +663,8 @@ def initialise_scheduler():
         try:
             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
 
@@ -894,11 +896,11 @@ 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):
@@ -908,11 +910,11 @@ def main(argv):
     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:
@@ -921,15 +923,15 @@ def main(argv):
             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 332690eea66..e013a6e6e8a 100644
--- a/extras/stripe-merge.c
+++ b/extras/stripe-merge.c
@@ -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 d4a3d0bf878..61446a9b84a 100644
--- a/extras/systemd/Makefile.am
+++ b/extras/systemd/Makefile.am
@@ -1,10 +1,14 @@
-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
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 181b5c1e9c7..d120c053a69 100644
--- a/extras/test/ld-preload-test/ld-preload-lib.c
+++ b/extras/test/ld-preload-test/ld-preload-lib.c
@@ -40,596 +40,576 @@
 /* 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
-futimes (int fd, const struct timeval times[2])
+futimes(int fd, const struct timeval times[2])
 {
-        intercept ("futimes", 2);
-        set_errno ();
-        return -1;
+    intercept("futimes", 2);
+    set_errno();
+    return -1;
 }
 
 int
-utime (const char *path, const struct utimbuf *buf)
+utime(const char *path, const struct utimbuf *buf)
 {
-        intercept ("utime", 2);
-        set_errno ();
-        return -1;
+    intercept("utime", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-mknod (const char *path, mode_t mode, dev_t dev)
+mknod(const char *path, mode_t mode, dev_t dev)
 {
-        intercept ("mknod", 2);
-        set_errno ();
-        return -1;
+    intercept("mknod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__xmknod (int ver, const char *path, mode_t mode, dev_t *dev)
+__xmknod(int ver, const char *path, mode_t mode, dev_t *dev)
 {
-        intercept ("__xmknod", 2);
-        set_errno ();
-        return -1;
+    intercept("__xmknod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-mkfifo (const char *path, mode_t mode)
+mkfifo(const char *path, mode_t mode)
 {
-        intercept ("mkfifo", 2);
-        set_errno ();
-        return -1;
+    intercept("mkfifo", 2);
+    set_errno();
+    return -1;
 }
 
 int
-unlink (const char *path)
+unlink(const char *path)
 {
-        intercept ("unlink", 2);
-        set_errno ();
-        return -1;
+    intercept("unlink", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-symlink (const char *oldpath, const char *newpath)
+symlink(const char *oldpath, const char *newpath)
 {
-        intercept ("symlink", 2);
-        set_errno ();
-        return -1;
+    intercept("symlink", 2);
+    set_errno();
+    return -1;
 }
 
 int
-readlink (const char *path, char *buf, size_t bufsize)
+readlink(const char *path, char *buf, size_t bufsize)
 {
-        intercept ("readlink", 1);
-        set_errno ();
-        return -1;
+    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 46e3e0e4172..54dde8c7d54 100644
--- a/extras/test/ld-preload-test/ld-preload-test.c
+++ b/extras/test/ld-preload-test/ld-preload-test.c
@@ -49,319 +49,310 @@
 #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 ab902697228..509952b4180 100644
--- a/extras/test/open-fd-tests.c
+++ b/extras/test/open-fd-tests.c
@@ -9,56 +9,59 @@
 #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 67c6a0fb33d..1d9c125db67 100644
--- a/extras/test/test-ffop.c
+++ b/extras/test/test-ffop.c
@@ -8,772 +8,820 @@
 #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/gluster-ta-volume.service b/extras/thin-arbiter/gluster-ta-volume.service
deleted file mode 100644
index 19be1757555..00000000000
--- a/extras/thin-arbiter/gluster-ta-volume.service
+++ /dev/null
@@ -1,13 +0,0 @@
-[Unit]
-Description = Thin-arbiter process to maintain quorum for replica volume
-After = network.target
-
-[Service]
-Environment = "LOG_LEVEL=WARNING"
-ExecStart = /usr/local/sbin/glusterfsd -N --volfile-id ta-vol -f /var/lib/glusterd/thin-arbiter/thin-arbiter.vol --brick-port 24007 --xlator-option ta-vol-server.transport.socket.listen-port=24007
-Restart = always
-KillMode=process
-SuccessExitStatus=15
-
-[Install]
-WantedBy = multi-user.target
diff --git a/extras/thin-arbiter/setup-thin-arbiter.sh b/extras/thin-arbiter/setup-thin-arbiter.sh
index 32fe7fc0cdd..0681b30ef3f 100755
--- a/extras/thin-arbiter/setup-thin-arbiter.sh
+++ b/extras/thin-arbiter/setup-thin-arbiter.sh
@@ -1,17 +1,62 @@
-#! /bin/bash
+#!/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
 
-cp -f extras/thin-arbiter/thin-arbiter.vol $volloc/thin-arbiter.vol
+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
+        if [ "$dir" = "directory" ]; then
             bpath=`echo "$line" | cut -d' ' -f 3`
             sed -i -- 's?'$bpath'?'$1'?g' $tafile
             return
@@ -19,50 +64,121 @@ volfile_set_brick_path () {
     done < $tafile
 }
 
-tapath="/mnt/thin-arbiter"
-echo "Volume file to be used to start thin-arbiter process is :"
-echo "$tafile"
-echo " "
-echo "Default thin-arbiter path is : $tapath"
-echo -n "Do you want to change path for thin arbiter volumes. (y/N): "
-echo " "
-read moveon
-
-if [ "${moveon}" = 'N' ] || [ "${moveon}" = 'n' ]; then
-	echo "Default brick path, $tapath, has been set"
-    echo "for all thin arbiter volumes using this node"
+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 " "
-else
-	echo -n "Enter brick path for thin arbiter volumes: "
-	read tapath
-	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"
+    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 " "
-fi
+    echo "========================================================"
 
-mkdir -p $tapath/.glusterfs/indices
-volfile_set_brick_path "$tapath"
+    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
 
-echo "Directory path to be used for thin-arbiter volume is: $tapath"
-echo " "
+    systemctl daemon-reload
+    systemctl enable gluster-ta-volume
+    systemctl stop gluster-ta-volume
+    systemctl start gluster-ta-volume
 
-echo "========================================================"
+    if [ $? == 0 ]; then
+        echo "thin-arbiter process has been setup and running"
+    else
+        echo "Failed to setup thin arbiter"
+        exit 1
+    fi
 
-echo "Installing and starting service for thin-arbiter process"
+}
 
-cp extras/thin-arbiter/gluster-ta-volume.service /etc/systemd/system/
+main()
+{
 
-chmod 0777 /etc/systemd/system/gluster-ta-volume.service
+    if [ "$#" -ne 1 ]; then
+        help
+        exit 0
+    fi
 
-systemctl daemon-reload
-systemctl enable gluster-ta-volume
-systemctl stop gluster-ta-volume
-systemctl start gluster-ta-volume
+    while getopts "sh" opt; do
+        case $opt in
+            h)
+                help
+                exit 0
+                ;;
+            s)
+                setup
+                exit 0
+                ;;
+            *)
+                help
+                exit 0
+                ;;
+        esac
+    done
+}
 
-if [ $? == 0 ]
-then
-    echo "thin-arbiter process is setup and running"
-else
-    echo "Failed to setup thin arbiter"
-fi
+main "$@"
diff --git a/extras/thin-arbiter/thin-arbiter.vol b/extras/thin-arbiter/thin-arbiter.vol
index 7a60f179891..c76babc7b3c 100644
--- a/extras/thin-arbiter/thin-arbiter.vol
+++ b/extras/thin-arbiter/thin-arbiter.vol
@@ -10,6 +10,7 @@ end-volume
 
 volume ta-locks
     type features/locks
+    option notify-contention yes
     subvolumes ta-thin-arbiter
 end-volume
 
@@ -32,11 +33,10 @@ volume ta-index
     subvolumes ta-io-threads
 end-volume
 
-volume ta-io-stats
+volume /mnt/thin-arbiter
     type debug/io-stats
     option count-fop-hits off
     option latency-measurement off
-    option log-level WARNING
     option unique-id /mnt/thin-arbiter
     subvolumes ta-index
 end-volume
@@ -53,5 +53,5 @@ volume ta-server
     option auth-path /mnt/thin-arbiter
     option transport.address-family inet
     option transport-type tcp
-    subvolumes ta-io-stats
+    subvolumes /mnt/thin-arbiter
 end-volume
diff --git a/extras/who-wrote-glusterfs/gitdm.domain-map b/extras/who-wrote-glusterfs/gitdm.domain-map
index 315355b08b8..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
diff --git a/geo-replication/gsyncd.conf.in b/geo-replication/gsyncd.conf.in
index bd04400ff69..9688c79fab7 100644
--- a/geo-replication/gsyncd.conf.in
+++ b/geo-replication/gsyncd.conf.in
@@ -23,6 +23,11 @@ configurable=false
 type=int
 value=1
 
+[master-distribution-count]
+configurable=false
+type=int
+value=1
+
 [glusterd-workdir]
 value = @GLUSTERD_WORKDIR@
 
@@ -108,7 +113,7 @@ value=1
 type=int
 help=Minimum time interval in seconds for passive worker to become Active
 
-[chnagelog-archive-format]
+[changelog-archive-format]
 value=%Y%m
 help=Processed changelogs will be archived in working directory. Pattern for archive file
 
@@ -118,7 +123,7 @@ type=bool
 help=Use this to set Active Passive mode to meta-volume.
 
 [meta-volume-mnt]
-value=/var/run/gluster/shared_storage
+value=/run/gluster/shared_storage
 help=Meta Volume or Shared Volume mount path
 
 [allow-network]
@@ -128,10 +133,11 @@ value=
 value=5
 type=int
 
-[use-tarssh]
-value=false
-type=bool
-help=Use sync-mode as tarssh
+[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 =
@@ -169,6 +175,12 @@ help=Do not sync deletes in Slave
 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
@@ -254,7 +266,9 @@ allowed_values=ERROR,INFO,WARNING,DEBUG
 
 [ssh-port]
 value=22
-validation=int
+validation=minmax
+min=1
+max=65535
 help=Set SSH port
 type=int
 
@@ -301,10 +315,12 @@ value=
 value=
 
 [rsync-opt-ignore-missing-args]
-value=
+value=true
+type=bool
 
 [rsync-opt-existing]
-value=
+value=true
+type=bool
 
 [log-rsync-performance]
 value=false
@@ -328,9 +344,6 @@ type=bool
 value=10
 type=int
 
-[changelog-archive-format]
-value=%Y%m
-
 [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 df2ee35b037..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,359 +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)
 {
-        int i                      = 0;
-        int j                      = 0;
-        char *nargv[argc + 4];
-        char *python = NULL;
+    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];
+    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];
 
-        nargv[j++] = NULL;
+    nargv[j++] = NULL;
 
-        execvp (python, nargv);
+    execvp(python, nargv);
 
-        fprintf (stderr, "exec of '%s' failed\n", python);
-        return 127;
+    fprintf(stderr, "exec of '%s' failed\n", python);
+    return 127;
 
- error:
-        fprintf (stderr, "gsyncd initializaion failed\n");
-        return 1;
+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 (ret == 1) {
-                if (pida[1] != -1) {
-                        fprintf (stderr, GSYNCD_PY" sibling is not unique");
-                        return -1;
-                }
-                pida[1] = pid;
+            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;
+    }
 
-        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;
+    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 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);
+        if (strcmp(name, "sshd") == 0) {
+            GF_FREE(name);
+            break;
         }
-        /* 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;
+        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 d048de0992b..f5f70d245e0 100755
--- a/geo-replication/src/gverify.sh
+++ b/geo-replication/src/gverify.sh
@@ -94,6 +94,7 @@ echo $cmd_line;
 function master_stats()
 {
     MASTERVOL=$1;
+    local inet6=$2;
     local d;
     local i;
     local disk_size;
@@ -102,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 $master_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;
@@ -124,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;
@@ -167,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
 
@@ -192,20 +208,21 @@ function main()
         exit 1;
     fi;
 
+    cmd_line=$(cmd_slave);
     if [[ -z "${GR_SSH_IDENTITY_KEY}" ]]; then
-        err=$((ssh -p ${SSH_PORT} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 "gluster --version") 2>&1)
+        ver=$(ssh -p ${SSH_PORT} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 bash -c "'$cmd_line'")
     else
-        err=$((ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 "gluster --version") 2>&1)
+        ver=$(ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 bash -c "'$cmd_line'")
     fi
 
-    if [ $? -ne 0 ]; then
-        echo "FORCE_BLOCKER|gluster command on $2@$3 failed. Error: $err" > $log_file
+    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':');
diff --git a/geo-replication/src/peer_georep-sshkey.py.in b/geo-replication/src/peer_georep-sshkey.py.in
index c35865db224..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/python2
+#!/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 5d19db88b80..8ecf38ded41 100644
--- a/geo-replication/src/peer_mountbroker.in
+++ b/geo-replication/src/peer_mountbroker.in
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
 
diff --git a/geo-replication/src/peer_mountbroker.py.in b/geo-replication/src/peer_mountbroker.py.in
index d101de561e4..40b90ffc560 100644
--- a/geo-replication/src/peer_mountbroker.py.in
+++ b/geo-replication/src/peer_mountbroker.py.in
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
 
@@ -11,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@"
 
@@ -46,7 +47,7 @@ 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)
@@ -145,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,
@@ -195,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()
@@ -216,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,
@@ -273,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 = ""
@@ -327,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,
@@ -368,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 19f0bfce1b7..d70e3368faf 100644
--- a/geo-replication/syncdaemon/Makefile.am
+++ b/geo-replication/syncdaemon/Makefile.am
@@ -2,7 +2,7 @@ syncdaemondir = $(GLUSTERFS_LIBEXECDIR)/python/syncdaemon
 
 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 changelogagent.py gsyncdstatus.py conf.py logutils.py \
-	subcmds.py argsupgrade.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/argsupgrade.py b/geo-replication/syncdaemon/argsupgrade.py
index 632271daf81..7af40633ef8 100644
--- a/geo-replication/syncdaemon/argsupgrade.py
+++ b/geo-replication/syncdaemon/argsupgrade.py
@@ -84,6 +84,10 @@ def upgrade():
     # 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
@@ -147,8 +151,11 @@ def upgrade():
 
             user, hname = remote_addr.split("@")
 
+            if not inet6:
+                hname = gethostbyname(hname)
+
             print(("ssh://%s@%s:gluster://127.0.0.1:%s" % (
-                user, gethostbyname(hname), vol)))
+                user, hname, vol)))
 
         sys.exit(0)
     elif "--normalize-url" in sys.argv:
@@ -268,7 +275,9 @@ def upgrade():
         p = ArgumentParser()
         p.add_argument("master")
         p.add_argument("slave")
-        p.add_argument("--config-set", nargs=2)
+        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]
 
@@ -280,8 +289,8 @@ def upgrade():
             "config-set",
             pargs.master.strip(":"),
             slave_url(pargs.slave),
-            pargs.config_set[0],
-            pargs.config_set[1]
+            "--name=%s" % pargs.name,
+            "--value=%s" % pargs.value
         ]
     elif "--config-check" in sys.argv:
         # --config-check georep_session_working_dir
@@ -344,3 +353,7 @@ def upgrade():
 
         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 5eade137d25..00000000000
--- a/geo-replication/syncdaemon/changelogagent.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/python2
-#
-# 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 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 5846b9b5f26..2042fa9cdfb 100644
--- a/geo-replication/syncdaemon/conf.py.in
+++ b/geo-replication/syncdaemon/conf.py.in
@@ -1,4 +1,3 @@
-#!/usr/bin/python2
 #
 # Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
diff --git a/geo-replication/syncdaemon/gsyncd.py b/geo-replication/syncdaemon/gsyncd.py
index 77fca4c9d1f..257ed72c6ae 100644
--- a/geo-replication/syncdaemon/gsyncd.py
+++ b/geo-replication/syncdaemon/gsyncd.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -22,8 +22,8 @@ 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
-from syncdutils import log_raise_exception, FreeObject, escape
+from syncdutils import (set_term_handler, finalize, lf,
+                        log_raise_exception, FreeObject, escape)
 import argsupgrade
 
 
@@ -47,6 +47,7 @@ def main():
         sys.exit(0)
 
     parser = ArgumentParser()
+    parser.add_argument("--inet6", action="store_true")
     sp = parser.add_subparsers(dest="subcmd")
 
     # Monitor Status File update
@@ -78,8 +79,6 @@ def main():
                    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("--rpc-fd",
-                   help="Read and Write fds for worker-agent communication")
     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")
@@ -91,19 +90,6 @@ def main():
     p.add_argument("-c", "--config-file", help="Config File")
     p.add_argument("--debug", action="store_true")
 
-    # Agent
-    p = sp.add_parser("agent")
-    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("--local-node", help="Local master node")
-    p.add_argument("--local-node-id", help="Local Node ID")
-    p.add_argument("--slave-id", help="Slave Volume ID")
-    p.add_argument("--rpc-fd",
-                   help="Read and Write fds for worker-agent communication")
-    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")
@@ -133,6 +119,8 @@ def main():
                    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")
@@ -165,8 +153,8 @@ def main():
     p = sp.add_parser("config-set")
     p.add_argument("master", help="Master Volume Name")
     p.add_argument("slave", help="Slave")
-    p.add_argument("name", help="Config Name")
-    p.add_argument("value", help="Config Value")
+    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")
 
@@ -228,7 +216,8 @@ def main():
     # 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"):
+    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,
@@ -252,6 +241,12 @@ def main():
     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,
@@ -261,8 +256,8 @@ def main():
 
     # Default label to print in log file
     label = args.subcmd
-    if args.subcmd in ("worker", "agent"):
-        # If Worker or agent, then add brick path also to label
+    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
@@ -305,7 +300,7 @@ def main():
 
     # Log message for loaded config file
     if config_file is not None:
-        logging.info(lf("Using session config file", path=config_file))
+        logging.debug(lf("Using session config file", path=config_file))
 
     set_term_handler()
     excont = FreeObject(exval=0)
diff --git a/geo-replication/syncdaemon/gsyncdconfig.py b/geo-replication/syncdaemon/gsyncdconfig.py
index 86b942d6dc9..8848071997a 100644
--- a/geo-replication/syncdaemon/gsyncdconfig.py
+++ b/geo-replication/syncdaemon/gsyncdconfig.py
@@ -10,12 +10,14 @@
 #
 
 try:
-    from configparser import configparser as ConfigParser, NoSectionError
+    from ConfigParser import RawConfigParser, NoSectionError
 except ImportError:
-    from ConfigParser import ConfigParser, NoSectionError
+    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
@@ -34,6 +36,7 @@ class GconfInvalidValue(Exception):
 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
@@ -91,7 +94,7 @@ class Gconf(object):
         if name != "all" and not self._is_configurable(name):
             raise GconfNotConfigurable()
 
-        cnf = ConfigParser()
+        cnf = RawConfigParser()
         with open(self.custom_conf_file) as f:
             cnf.readfp(f)
 
@@ -135,7 +138,7 @@ class Gconf(object):
         if curr_val == value:
             return True
 
-        cnf = ConfigParser()
+        cnf = RawConfigParser()
         with open(self.custom_conf_file) as f:
             cnf.readfp(f)
 
@@ -162,6 +165,11 @@ class Gconf(object):
         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 = []
@@ -170,7 +178,7 @@ class Gconf(object):
         self.session_conf_items = []
         self.default_values = {}
 
-        conf = ConfigParser()
+        conf = RawConfigParser()
         # Default Template config file
         with open(self.default_conf_file) as f:
             conf.readfp(f)
@@ -229,12 +237,19 @@ class Gconf(object):
         self._tmpl_substitute()
         self._do_typecast()
 
-    def reload(self):
+    def reload(self, with_lock=True):
         if self._is_config_changed():
-            self._load()
+            if with_lock:
+                self._load_with_lock()
+            else:
+                self._load()
 
-    def get(self, name, default_value=None):
-        return self.gconf.get(name, default_value)
+    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 = {}
@@ -275,8 +290,9 @@ class Gconf(object):
         return cnf
 
     def getr(self, name, default_value=None):
-        self.reload()
-        return self.get(name, default_value)
+        with self.lock:
+            self.reload(with_lock=False)
+            return self.get(name, default_value, with_lock=False)
 
     def get_help(self, name=None):
         pass
@@ -313,6 +329,9 @@ class Gconf(object):
         if item["validation"] == "unixtime":
             return validate_unixtime(value)
 
+        if item["validation"] == "int":
+            return validate_int(value)
+
         return False
 
     def _is_config_changed(self):
@@ -325,6 +344,53 @@ class Gconf(object):
 
         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:
@@ -338,11 +404,13 @@ def validate_unixtime(value):
 
 
 def validate_minmax(value, minval, maxval):
-    value = int(value)
-    minval = int(minval)
-    maxval = int(maxval)
-
-    return value >= minval and value <= 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):
diff --git a/geo-replication/syncdaemon/gsyncdstatus.py b/geo-replication/syncdaemon/gsyncdstatus.py
index 87fa09c070c..1a655ff8887 100644
--- a/geo-replication/syncdaemon/gsyncdstatus.py
+++ b/geo-replication/syncdaemon/gsyncdstatus.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
@@ -23,8 +23,8 @@ 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")
diff --git a/geo-replication/syncdaemon/libcxattr.py b/geo-replication/syncdaemon/libcxattr.py
index 2d186b95c89..e6406c36bd7 100644
--- a/geo-replication/syncdaemon/libcxattr.py
+++ b/geo-replication/syncdaemon/libcxattr.py
@@ -9,7 +9,9 @@
 #
 
 import os
-from ctypes import CDLL, create_string_buffer, get_errno
+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):
@@ -38,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):
@@ -65,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 []
@@ -73,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 da12438d069..a3bda7282c0 100644
--- a/geo-replication/syncdaemon/libgfchangelog.py
+++ b/geo-replication/syncdaemon/libgfchangelog.py
@@ -9,130 +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("libgfchangelog.so", 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/master.py b/geo-replication/syncdaemon/master.py
index ac31e3fb81a..9501aeae6b5 100644
--- a/geo-replication/syncdaemon/master.py
+++ b/geo-replication/syncdaemon/master.py
@@ -22,11 +22,13 @@ from threading import Condition, Lock
 from datetime import datetime
 
 import gsyncdconfig as gconf
+import libgfchangelog
 from rconf import rconf
-from syncdutils import Thread, GsyncdError, escape_space_newline
-from syncdutils import unescape_space_newline, gauxpfx, escape
-from syncdutils import lstat, errno_wrap, FreeObject, lf, matching_disk_gfid
-from syncdutils import NoStimeAvailable, PartialHistoryAvailable
+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)
 
@@ -65,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]
@@ -448,18 +453,10 @@ class GMasterCommon(object):
         if rconf.mgmt_lock_fd:
             try:
                 fcntl.lockf(rconf.mgmt_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                if not rconf.active_earlier:
-                    rconf.active_earlier = True
-                    logging.info(lf("Got lock Becoming ACTIVE",
-                                    brick=rconf.args.local_path))
                 return True
             except:
                 ex = sys.exc_info()[1]
                 if isinstance(ex, IOError) and ex.errno in (EACCES, EAGAIN):
-                    if not rconf.passive_earlier:
-                        rconf.passive_earlier = True
-                        logging.info(lf("Didn't get lock Becoming PASSIVE",
-                                        brick=rconf.local_path))
                     return False
                 raise
 
@@ -494,18 +491,10 @@ class GMasterCommon(object):
             ex = sys.exc_info()[1]
             if isinstance(ex, IOError) and ex.errno in (EACCES, EAGAIN):
                 # cannot grab, it's taken
-                if not rconf.passive_earlier:
-                    rconf.passive_earlier = True
-                    logging.info(lf("Didn't get lock Becoming PASSIVE",
-                                    brick=rconf.args.local_path))
                 rconf.mgmt_lock_fd = fd
                 return False
             raise
 
-        if not rconf.active_earlier:
-            rconf.active_earlier = True
-            logging.info(lf("Got lock Becoming ACTIVE",
-                            brick=rconf.args.local_path))
         return True
 
     def should_crawl(self):
@@ -530,7 +519,7 @@ class GMasterCommon(object):
         # If crawlwrap is called when partial history available,
         # then it sets register_time which is the time when geo-rep
         # worker registered to changelog consumption. Since nsec is
-        # not considered in register time, their are chances of skipping
+        # 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
@@ -712,7 +701,7 @@ class GMasterChangelogMixin(GMasterCommon):
     TYPE_ENTRY = "E "
 
     MAX_EF_RETRIES = 10
-    MAX_OE_RETRIES = 5
+    MAX_OE_RETRIES = 10
 
     # flat directory hierarchy for gfid based access
     FLAT_DIR_HIERARCHY = '.'
@@ -808,6 +797,7 @@ class GMasterChangelogMixin(GMasterCommon):
         pfx = gauxpfx()
         fix_entry_ops = []
         failures1 = []
+        remove_gfids = set()
         for failure in failures:
             if failure[2]['name_mismatch']:
                 pbname = failure[2]['slave_entry']
@@ -823,7 +813,7 @@ class GMasterChangelogMixin(GMasterCommon):
                 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('Entry not present on master. Fixing gfid '
+                    logging.debug(lf('Entry not present on master. Fixing gfid '
                                     'mismatch in slave. Deleting the entry',
                                     retry_count=retry_count,
                                     entry=repr(failure)))
@@ -838,46 +828,67 @@ class GMasterChangelogMixin(GMasterCommon):
                             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):
                     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.info(lf('Fixing gfid mismatch in slave. '
+                        logging.debug(lf('Fixing gfid mismatch in slave. '
                                         ' Safe to ignore, take out entry',
                                         retry_count=retry_count,
                                         entry=repr(failure)))
-                        entries.remove(failure[0])
+                        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(gconf.local_path,
-                                                            ".glusterfs",
-                                                            slave_gfid[0:2],
-                                                            slave_gfid[2:4],
-                                                            slave_gfid))
+                        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])
                         src_entry = pbname
-                        logging.info(lf('Fixing dir name/gfid mismatch in '
+                        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.info(lf('Fixing dir name/gfid mismatch'
+                            logging.debug(lf('Fixing dir name/gfid mismatch'
                                             ' in slave. Safe to ignore, '
                                             'take out entry',
                                             retry_count=retry_count,
                                             entry=repr(failure)))
-                            entries.remove(failure[0])
+                            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.info(lf('Fixing dir name/gfid mismatch'
+                            logging.debug(lf('Fixing dir name/gfid mismatch'
                                             ' in slave. Renaming',
                                             retry_count=retry_count,
                                             entry=repr(rename_dict)))
@@ -887,7 +898,7 @@ class GMasterChangelogMixin(GMasterCommon):
                         # 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.info(lf('Fixing file gfid mismatch in slave. '
+                        logging.debug(lf('Fixing file gfid mismatch in slave. '
                                         'Hardlink/Rename Case. Deleting entry',
                                         retry_count=retry_count,
                                         entry=repr(failure)))
@@ -896,31 +907,52 @@ class GMasterChangelogMixin(GMasterCommon):
                                  gfid=failure[2]['slave_gfid'],
                                  entry=pbname))
             elif failure[1] == ENOENT:
-                # Ignore ENOENT error for fix_entry_ops aka retry_count > 1
-                if retry_count > 1:
-                    logging.info(lf('ENOENT error while fixing entry ops. '
-                                    'Safe to ignore, take out entry',
+                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)))
-                    entries.remove(failure[0])
-                elif op in ('MKNOD', 'CREATE', 'MKDIR'):
-                    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.info(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
             failures1 = self.slave.server.entry_ops(fix_entry_ops)
-            if not failures1:
-                logging.info("Successfully fixed entry ops with gfid mismatch")
 
         return (failures1, fix_entry_ops)
 
@@ -943,7 +975,7 @@ class GMasterChangelogMixin(GMasterCommon):
                     failures1, retries, entry_ops1)
                 if not failures2:
                     pending_failures = False
-                    logging.info(lf('Sucessfully fixed entry ops with gfid '
+                    logging.info(lf('Successfully fixed entry ops with gfid '
                                  'mismatch', retry_count=retries))
                 else:
                     pending_failures = True
@@ -1053,7 +1085,7 @@ class GMasterChangelogMixin(GMasterCommon):
                     # 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]),
@@ -1094,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):
@@ -1117,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])
@@ -1164,7 +1207,6 @@ 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))
 
@@ -1179,16 +1221,21 @@ class GMasterChangelogMixin(GMasterCommon):
             self.status.inc_value("entry", len(entries))
 
             failures = self.slave.server.entry_ops(entries)
-            count = 0
-            while failures and count < self.MAX_OE_RETRIES:
-                count += 1
-                self.handle_entry_failures(failures, entries)
-                logging.info("Retry original entries. count = %s" % count)
-                failures = self.slave.server.entry_ops(entries)
-                if not failures:
-                    logging.info("Sucessfully fixed all entry ops with gfid "
-                                 "mismatch")
-                    break
+
+            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))
@@ -1225,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
 
@@ -1420,7 +1467,7 @@ class GMasterChangelogMixin(GMasterCommon):
         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):
@@ -1453,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",
@@ -1472,10 +1519,9 @@ class GMasterChangelogMixin(GMasterCommon):
 
         self.changelogs_batch_process(changes)
 
-    def register(self, register_time, changelog_agent, status):
-        self.changelog_agent = changelog_agent
+    def register(self, register_time, status):
         self.sleep_interval = gconf.get("change-interval")
-        self.changelog_done_func = self.changelog_agent.done
+        self.changelog_done_func = libgfchangelog.done
         self.tempdir = self.setup_working_dir()
         self.processed_changelogs_dir = os.path.join(self.tempdir,
                                                      ".processed")
@@ -1484,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,
@@ -1502,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,
@@ -1516,7 +1567,7 @@ class GMasterChangeloghistoryMixin(GMasterChangelogMixin):
         # location then consuming history will not work(Known issue as of now)
         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,
@@ -1528,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",
@@ -1584,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 = []
@@ -1702,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
 
diff --git a/geo-replication/syncdaemon/monitor.py b/geo-replication/syncdaemon/monitor.py
index 97274f32422..6aa7b9dfc99 100644
--- a/geo-replication/syncdaemon/monitor.py
+++ b/geo-replication/syncdaemon/monitor.py
@@ -20,13 +20,16 @@ import random
 
 from resource import SSH
 import gsyncdconfig as gconf
+import libgfchangelog
 from rconf import rconf
-from syncdutils import select, waitpid, errno_wrap, lf, grabpidfile
-from syncdutils import set_term_handler, GsyncdError
-from syncdutils import Thread, finalize, Volinfo, VolinfoFromGconf
-from syncdutils import gf_event, EVENT_GEOREP_FAULTY, get_up_nodes
+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
-from syncdutils import unshare_propagation_supported
+import py2py3
+from py2py3 import pipe
 
 ParseError = XET.ParseError if hasattr(XET, 'ParseError') else SyntaxError
 
@@ -35,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)
@@ -77,7 +82,7 @@ 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
 
@@ -146,7 +151,7 @@ class Monitor(object):
                     remote_host = "%s@%s" % (remote_user, remote_new[0])
                     remote_id = remote_new[1]
 
-            # Spawn the worker and agent in lock to avoid fd leak
+            # Spawn the worker in lock to avoid fd leak
             self.lock.acquire()
 
             self.status[w[0]['dir']].set_worker_status(self.ST_INIT)
@@ -154,44 +159,10 @@ class Monitor(object):
                             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)
-                args_to_agent = argv + [
-                    'agent',
-                    rconf.args.master,
-                    rconf.args.slave,
-                    '--local-path', w[0]['dir'],
-                    '--local-node', w[0]['host'],
-                    '--local-node-id', w[0]['uuid'],
-                    '--slave-id', suuid,
-                    '--rpc-fd', ','.join([str(ra), str(wa), str(rw), str(ww)])
-                ]
-
-                if rconf.args.config_file is not None:
-                    args_to_agent += ['-c', rconf.args.config_file]
-
-                if rconf.args.debug:
-                    args_to_agent.append("--debug")
-
-                os.execv(sys.executable, args_to_agent)
-
-            pr, pw = os.pipe()
+            pr, pw = pipe()
             cpid = os.fork()
             if cpid == 0:
                 os.close(pr)
-                os.close(ra)
-                os.close(wa)
 
                 args_to_worker = argv + [
                     'worker',
@@ -202,8 +173,6 @@ class Monitor(object):
                     '--local-node', w[0]['host'],
                     '--local-node-id', w[0]['uuid'],
                     '--slave-id', suuid,
-                    '--rpc-fd',
-                    ','.join([str(rw), str(ww), str(ra), str(wa)]),
                     '--subvol-num', str(w[2]),
                     '--resource-remote', remote_host,
                     '--resource-remote-id', remote_id
@@ -234,14 +203,8 @@ class Monitor(object):
                         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()
@@ -250,42 +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)
@@ -300,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
@@ -329,18 +265,15 @@ class Monitor(object):
         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,
+                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])
@@ -350,8 +283,8 @@ class Monitor(object):
         # 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 and
-        # agent, these processes can hold the reference to fd of status
+        # 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.
@@ -367,7 +300,7 @@ def distribute(master, slave):
     if rconf.args.use_gconf_volinfo:
         mvol = VolinfoFromGconf(master.volume, master=True)
     else:
-        mvol = Volinfo(master.volume, master.host)
+        mvol = Volinfo(master.volume, master.host, master=True)
     logging.debug('master bricks: ' + repr(mvol.bricks))
     prelude = []
     slave_host = None
@@ -383,7 +316,7 @@ def distribute(master, slave):
     if rconf.args.use_gconf_volinfo:
         svol = VolinfoFromGconf(slave.volume, master=False)
     else:
-        svol = Volinfo(slave.volume, "localhost", prelude)
+        svol = Volinfo(slave.volume, "localhost", prelude, master=False)
 
     sbricks = svol.bricks
     suuid = svol.uuid
@@ -438,7 +371,7 @@ def startup(go_daemon=True):
     if not go_daemon:
         return
 
-    x, y = os.pipe()
+    x, y = pipe()
     cpid = os.fork()
     if cpid:
         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/rconf.py b/geo-replication/syncdaemon/rconf.py
index ccac62c63a8..ff716ee4d6d 100644
--- a/geo-replication/syncdaemon/rconf.py
+++ b/geo-replication/syncdaemon/rconf.py
@@ -21,12 +21,6 @@ class RConf(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
diff --git a/geo-replication/syncdaemon/repce.py b/geo-replication/syncdaemon/repce.py
index 6910fd068ad..c622afa6373 100644
--- a/geo-replication/syncdaemon/repce.py
+++ b/geo-replication/syncdaemon/repce.py
@@ -28,13 +28,13 @@ except ImportError:
 
 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
@@ -54,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):
diff --git a/geo-replication/syncdaemon/resource.py b/geo-replication/syncdaemon/resource.py
index df4006f971a..f12c7ceaa36 100644
--- a/geo-replication/syncdaemon/resource.py
+++ b/geo-replication/syncdaemon/resource.py
@@ -19,28 +19,31 @@ import struct
 import logging
 import tempfile
 import subprocess
-from errno import EEXIST, ENOENT, ENODATA, ENOTDIR, ELOOP, EACCES
-from errno import EISDIR, ENOTEMPTY, ESTALE, EINVAL, EBUSY, EPERM
+from errno import (EEXIST, ENOENT, ENODATA, ENOTDIR, ELOOP, EACCES,
+                   EISDIR, ENOTEMPTY, ESTALE, EINVAL, EBUSY, EPERM)
 import errno
 
 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, 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 lf, Popen, sup
-from syncdutils import Xattr, matching_disk_gfid, get_gfid_from_mnt
-from syncdutils import unshare_propagation_supported, get_slv_dir_path
+from py2py3 import (pipe, str_to_bytearray, entry_pack_reg,
+                    entry_pack_reg_stat, entry_pack_mkdir,
+                    entry_pack_symlink)
 
 
 ENOTSUP = getattr(errno, 'ENOTSUP', 'EOPNOTSUPP')
@@ -145,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())
@@ -235,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]
@@ -257,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]
@@ -279,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]
@@ -302,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]
@@ -370,38 +378,9 @@ 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.
@@ -415,7 +394,7 @@ class Server(object):
                 return
 
             if not matching_disk_gfid(gfid, entry):
-                collect_failure(e, EEXIST)
+                collect_failure(e, EEXIST, uid, gid)
                 return
 
             if op == 'UNLINK':
@@ -431,7 +410,7 @@ 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
@@ -444,13 +423,18 @@ class Server(object):
             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 \
+                if isinstance(disk_gfid, str) and \
                    e['gfid'] != disk_gfid:
                     slv_entry_info['gfid_mismatch'] = True
                     st = lstat(en)
@@ -505,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",
@@ -513,13 +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
@@ -528,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.
@@ -540,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
@@ -568,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.
@@ -577,15 +567,15 @@ 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
@@ -597,6 +587,8 @@ class Server(object):
                     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
@@ -613,23 +605,23 @@ class Server(object):
                 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']
                 # The matching disk gfid check validates two things
@@ -641,32 +633,38 @@ class Server(object):
                 # 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:
                             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(gfid, bname,
+                                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)
+                                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
@@ -690,16 +688,23 @@ 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])
-                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
@@ -708,7 +713,7 @@ class Server(object):
                     path = os.path.join(pfx, gfid)
                     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
 
@@ -735,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],
@@ -746,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
 
@@ -834,7 +835,8 @@ class Mounter(object):
 
     def umount_l(self, d):
         """perform lazy umount"""
-        po = Popen(self.make_umount_argv(d), stderr=subprocess.PIPE)
+        po = Popen(self.make_umount_argv(d), stderr=subprocess.PIPE,
+                   universal_newlines=True)
         po.wait()
         return po
 
@@ -858,7 +860,7 @@ class Mounter(object):
         change into the mount, and lazy unmount the
         filesystem.
         """
-        mpi, mpo = os.pipe()
+        mpi, mpo = pipe()
         mh = Popen.fork()
         if mh:
             # Parent
@@ -869,7 +871,9 @@ class Mounter(object):
             if self.mntpt:
                 # mntpt is determined pre-mount
                 d = self.mntpt
-                os.write(mpo, d + '\0')
+                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()
@@ -877,8 +881,11 @@ class Mounter(object):
             if not d:
                 # mntpt is determined during mount
                 d = self.mntpt
-                os.write(mpo, d + '\0')
-            os.write(mpo, 'M')
+                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")
@@ -907,6 +914,7 @@ class Mounter(object):
                 mntdata = ''
                 while True:
                     c = os.read(mpi, 1)
+                    c = c.decode()
                     if not c:
                         break
                     mntdata += c
@@ -943,6 +951,16 @@ class Mounter(object):
                 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)
+
         logging.debug('auxiliary glusterfs mount prepared')
 
 
@@ -950,7 +968,7 @@ class DirectMounter(Mounter):
 
     """mounter backend which calls mount(8), umount(8) directly"""
 
-    mountkw = {'stderr': subprocess.PIPE}
+    mountkw = {'stderr': subprocess.PIPE, 'universal_newlines': True}
     glusterprog = 'glusterfs'
 
     @staticmethod
@@ -973,7 +991,8 @@ class MountbrokerMounter(Mounter):
 
     """mounter backend using the mountbroker gluster service"""
 
-    mountkw = {'stderr': subprocess.PIPE, 'stdout': subprocess.PIPE}
+    mountkw = {'stderr': subprocess.PIPE, 'stdout': subprocess.PIPE,
+               'universal_newlines': True}
     glusterprog = 'gluster'
 
     @classmethod
@@ -1014,6 +1033,7 @@ class GLUSTERServer(Server):
         """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})',
@@ -1236,9 +1256,6 @@ class GLUSTER(object):
         # register the crawlers and start crawling
         # g1 ==> Xsync, g2 ==> config.change_detector(changelog by default)
         # g3 ==> changelog History
-        (inf, ouf, ra, wa) = rconf.args.rpc_fd.split(',')
-        changelog_agent = RepceClient(int(inf), int(ouf))
-
         status = GeorepStatus(gconf.get("state-file"),
                               rconf.args.local_node,
                               rconf.args.local_path,
@@ -1246,12 +1263,6 @@ class GLUSTER(object):
                               rconf.args.master,
                               rconf.args.slave)
         status.reset_on_worker_start()
-        rv = changelog_agent.version()
-        if int(rv) != CHANGELOG_AGENT_CLIENT_VERSION:
-            raise GsyncdError(
-                "RePCe major version mismatch(changelog agent): "
-                "local %s, remote %s" %
-                (CHANGELOG_AGENT_CLIENT_VERSION, rv))
 
         try:
             workdir = g2.setup_working_dir()
@@ -1262,17 +1273,16 @@ class GLUSTER(object):
                 # register with the changelog library
                 # 9 == log level (DEBUG)
                 # 5 == connection retries
-                changelog_agent.init()
-                changelog_agent.register(rconf.args.local_path,
-                                         workdir,
-                                         gconf.get("changelog-log-file"),
-                                         get_changelog_log_level(
-                                             gconf.get("changelog-log-level")),
-                                         g2.CHANGELOG_CONN_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, changelog_agent, status)
-            g3.register(register_time, changelog_agent, status)
+            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)
@@ -1407,7 +1417,9 @@ class SSH(object):
                 '--slave-gluster-log-level',
                 gconf.get("slave-gluster-log-level"),
                 '--slave-gluster-command-dir',
-                gconf.get("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')
@@ -1472,12 +1484,13 @@ class SSH(object):
 
         if log_rsync_performance:
             # use stdout=PIPE only when log_rsync_performance enabled
-            # Else rsync will write to stdout and nobody is their
+            # 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)
+                       stderr=subprocess.PIPE, universal_newlines=True)
         else:
-            po = Popen(argv, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+            po = Popen(argv, stdin=subprocess.PIPE, stderr=subprocess.PIPE,
+                       universal_newlines=True)
 
         for f in files:
             po.stdin.write(f)
@@ -1509,7 +1522,7 @@ class SSH(object):
 
         return po
 
-    def tarssh(self, files, slaveurl, log_err=False):
+    def tarssh(self, files, 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)
@@ -1517,32 +1530,49 @@ class SSH(object):
         if not files:
             raise GsyncdError("no files to sync")
         logging.debug("files: " + ", ".join(files))
-        (host, rdir) = slaveurl.split(':')
+        (host, rdir) = self.slaveurl.split(':')
+
         tar_cmd = ["tar"] + \
             ["--sparse", "-cf", "-", "--files-from", "-"]
-        ssh_cmd = gconf.get("ssh-command-tar").split() + \
+        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)
-        p1 = Popen(ssh_cmd, stdin=p0.stdout, stderr=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.
-        # wait for tar to terminate, collecting any errors, further
-        # waiting for transfer to complete
-        _, stderr1 = p1.communicate()
 
         # 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()
+
+        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]:
diff --git a/geo-replication/syncdaemon/subcmds.py b/geo-replication/syncdaemon/subcmds.py
index 11d263d7e03..b8508532e30 100644
--- a/geo-replication/syncdaemon/subcmds.py
+++ b/geo-replication/syncdaemon/subcmds.py
@@ -73,7 +73,11 @@ def subcmd_worker(args):
     Popen.init_errhandler()
     fcntl.fcntl(args.feedback_fd, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
     local = GLUSTER("localhost", args.master)
-    slavehost, slavevol = args.slave.split("::")
+    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()
@@ -93,26 +97,21 @@ def subcmd_slave(args):
     local.service_loop()
 
 
-def subcmd_agent(args):
-    import os
-    from changelogagent import agent, Changelog
-    from syncdutils import lf
-
-    os.setsid()
-    logging.debug(lf("RPC FD",
-                     rpc_fd=repr(args.rpc_fd)))
-    return agent(Changelog(), args.rpc_fd)
-
-
 def subcmd_voluuidget(args):
     from subprocess import Popen, PIPE
     import xml.etree.ElementTree as XET
 
     ParseError = XET.ParseError if hasattr(XET, 'ParseError') else SyntaxError
 
-    po = Popen(['gluster', '--xml', '--remote-host=' + args.host,
-                'volume', 'info', args.volname], bufsize=0,
-               stdin=None, stdout=PIPE, stderr=PIPE)
+    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:
diff --git a/geo-replication/syncdaemon/syncdutils.py b/geo-replication/syncdaemon/syncdutils.py
index 93e09756198..a3df103e76c 100644
--- a/geo-replication/syncdaemon/syncdutils.py
+++ b/geo-replication/syncdaemon/syncdutils.py
@@ -21,8 +21,8 @@ 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, 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
@@ -37,10 +37,10 @@ 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
@@ -55,14 +55,15 @@ from rconf import rconf
 
 from hashlib import sha256 as sha256
 
+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
@@ -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:
@@ -160,7 +174,8 @@ def setup_ssh_ctl(ctld, remote_addr, resource_url):
     rconf.ssh_ctl_dir = ctld
     content = "SLAVE_HOST=%s\nSLAVE_RESOURCE_URL=%s" % (remote_addr,
                                                         resource_url)
-    content_sha256 = sha256hex(content)
+    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
@@ -172,7 +187,7 @@ def setup_ssh_ctl(ctld, remote_addr, resource_url):
     fname = os.path.join(rconf.ssh_ctl_dir,
                          "%s.mft" % content_sha256)
 
-    create_manifest(fname, content)
+    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]
@@ -185,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:
@@ -199,6 +214,7 @@ def grabfile(fname, content=None):
         try:
             f.truncate()
             f.write(content)
+            f.flush()
         except:
             f.close()
             raise
@@ -261,7 +277,8 @@ def finalize(*args, **kwargs):
             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)
+        p0 = subprocess.Popen(umount_cmd, stderr=subprocess.PIPE,
+                              universal_newlines=True)
         _, errdata = p0.communicate()
         if p0.returncode == 0:
             try:
@@ -327,13 +344,24 @@ def log_raise_exception(excont):
                                                         ECONNABORTED):
             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)
 
@@ -560,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',
@@ -596,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)
 
 
@@ -636,7 +663,8 @@ def unshare_propagation_supported():
     unshare_mnt_propagation = False
     p = subprocess.Popen(["unshare", "--help"],
                          stderr=subprocess.PIPE,
-                         stdout=subprocess.PIPE)
+                         stdout=subprocess.PIPE,
+                         universal_newlines=True)
     out, err = p.communicate()
     if p.returncode == 0:
         if "propagation" in out:
@@ -653,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]
@@ -665,9 +694,10 @@ 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)
+        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"
@@ -678,19 +708,32 @@ def get_slv_dir_path(slv_host, slv_volume, gfid):
                                gfid[2:4],
                                gfid], [ENOENT], [ESTALE])
         if dir_path != ENOENT:
-            break
-
-    if not isinstance(dir_path, int):
-        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]
-            pfx = gauxpfx()
-            dir_entry = os.path.join(pfx, pargfid, basename)
-            return dir_entry
+            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
 
@@ -700,12 +743,12 @@ 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):
@@ -842,7 +885,7 @@ class Popen(subprocess.Popen):
                 break
             b = os.read(self.stderr.fileno(), 1024)
             if b:
-                elines.append(b)
+                elines.append(b.decode())
             else:
                 break
         self.stderr.close()
@@ -851,12 +894,31 @@ class Popen(subprocess.Popen):
             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=[]):
-        po = Popen(prelude + ['gluster', '--xml', '--remote-host=' + host,
+    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)
+                   stdout=PIPE, stderr=PIPE, universal_newlines=True)
         vix = po.stdout.read()
         po.wait()
         po.terminate_geterr()
@@ -887,7 +949,7 @@ class Volinfo(object):
     @memoize
     def bricks(self):
         def bparse(b):
-            host, dirp = b.find("name").text.split(':', 2)
+            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')]
 
@@ -919,6 +981,14 @@ class Volinfo(object):
         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):
@@ -955,6 +1025,16 @@ class VolinfoFromGconf(object):
     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):
@@ -968,8 +1048,22 @@ class VolinfoFromGconf(object):
         out = []
         for b in bricks_data:
             parts = b.split(":")
-            bpath = parts[2] if len(parts) == 3 else ""
-            out.append({"host": parts[1], "dir": bpath, "uuid": parts[0]})
+            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
 
@@ -987,6 +1081,9 @@ class VolinfoFromGconf(object):
     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):
diff --git a/geo-replication/tests/__init__.py b/geo-replication/tests/__init__.py
index 13065ca3d3c..b4648b69645 100644
--- a/geo-replication/tests/__init__.py
+++ b/geo-replication/tests/__init__.py
@@ -1,4 +1,3 @@
-#!/usr/bin/python2
 #
 # 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 13065ca3d3c..b4648b69645 100644
--- a/geo-replication/tests/unit/__init__.py
+++ b/geo-replication/tests/unit/__init__.py
@@ -1,4 +1,3 @@
-#!/usr/bin/python2
 #
 # 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 b4ce8fa053b..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/python2
+#!/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 fe439a50b38..ff537ab2660 100644
--- a/geo-replication/tests/unit/test_syncdutils.py
+++ b/geo-replication/tests/unit/test_syncdutils.py
@@ -1,4 +1,3 @@
-#!/usr/bin/python2
 #
 # 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 6af4e108f7f..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} -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 9d4d62fdf38..b6d63146e14 100644
--- a/glusterfs.spec.in
+++ b/glusterfs.spec.in
@@ -9,13 +9,13 @@
 ## All argument definitions should be placed here and keep them sorted
 ##
 
-# bd
-# 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}
+# 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 ( 0%{?rhel} && 0%{?rhel} < 6 || 0%{?sles_version} )
-%global _without_bd --disable-bd-xlator
+%if ( 0%{?rhel} && 0%{?rhel} < 7 )
+%global _with_asan %{nil}
 %endif
 
 # cmocka
@@ -43,11 +43,6 @@
 # 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
@@ -75,16 +70,6 @@
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without ocf
 %{?_without_ocf:%global _without_ocf --without-ocf}
 
-# rdma
-# 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
-
 # server
 # if you wish to build rpms without server components, compile like this
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without server
@@ -108,10 +93,13 @@
 %global _without_syslog --disable-syslog
 %endif
 
-# tier
-# Disable data-tiering on EL5, sqlite is too old
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-%global _without_tiering --disable-tiering
+# 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} < 7 )
+%global _with_tsan %{nil}
 %endif
 
 # valgrind
@@ -123,7 +111,13 @@
 ## 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
 
@@ -137,20 +131,22 @@
 %global _with_tmpfilesdir --without-tmpfilesdir
 %endif
 
-# Eventing
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-%global _without_events --disable-events
-%endif
-
 # 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_tiering --disable-tiering
 %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
 %if ( 0%{?rhel} && 0%{?rhel} <= 6 )
 %{!?python2_sitelib: %global python2_sitelib %(python2 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())")}
@@ -168,6 +164,7 @@
 # can't seem to make a generic macro that works
 %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
@@ -191,11 +188,6 @@
 
 %{!?_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:
@@ -227,13 +219,11 @@ Version:          @PACKAGE_VERSION@
 Release:          0.@PACKAGE_RELEASE@%{?dist}
 %endif
 License:          GPLv2 or LGPLv3+
-Group:            System Environment/Base
 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
@@ -243,50 +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} && 0%{?rhel} <= 7 )
+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 )
+%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
@@ -295,121 +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.
-
-%if ( 0%{!?_without_server:1} )
 %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
-%endif
 
-%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
+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
@@ -422,21 +363,48 @@ 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 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 FUSE based clients and inlcudes the
 glusterfs(d) binary.
 
-%package cloudsync-plugins
-Summary:          Cloudsync Plugins
-BuildRequires:    libcurl-devel
+%if ( 0%{!?_without_server:1} )
+%package ganesha
+Summary:          NFS-Ganesha configuration
+Group:            Applications/File
 
-%description cloudsync-plugins
+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
@@ -445,28 +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 cloudsync plugins for archival feature.
+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
-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
@@ -474,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.
 
-%description -n python-gluster %{_python_gluster_description}
+This package provides the libgfrpc library
 
-%package -n python2-gluster
+%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 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 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
@@ -582,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
@@ -599,12 +688,11 @@ 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,
@@ -614,14 +702,17 @@ like Pacemaker.
 %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
@@ -646,14 +737,11 @@ 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} >= 28 )
-Requires:         python2-pyxattr
+%if ( 0%{?fedora} && 0%{?fedora} > 27 ) || ( 0%{?rhel} && 0%{?rhel} > 7 )
+Requires:         python%{_pythonver}-pyxattr
 %else
 Requires:         pyxattr
 %endif
@@ -663,42 +751,50 @@ Requires:         valgrind
 
 %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%{_pythonver} python%{_pythonver}-prettytable
+Requires:         python%{_pythonver}-gluster = %{version}-%{release}
+%if ( 0%{?rhel} && 0%{?rhel} < 8 )
 Requires:         python-requests
 %else
-Requires:         python2-requests
+Requires:         python%{_pythonver}-requests
 %endif
 %if ( 0%{?rhel} && 0%{?rhel} < 7 )
 Requires:         python-argparse
@@ -714,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 )
@@ -727,22 +825,21 @@ 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}
 
@@ -761,25 +858,18 @@ make check
 %install
 rm -rf %{buildroot}
 make install DESTDIR=%{buildroot}
+%if ( 0%{!?_without_server:1} )
 %if ( 0%{_for_fedora_koji_builds} )
 install -D -p -m 0644 %{SOURCE1} \
     %{buildroot}%{_sysconfdir}/sysconfig/glusterd
 install -D -p -m 0644 %{SOURCE2} \
     %{buildroot}%{_sysconfdir}/sysconfig/glusterfsd
 %else
-%if ( 0%{!?_without_server:1} )
 install -D -p -m 0644 extras/glusterd-sysconfig \
     %{buildroot}%{_sysconfdir}/sysconfig/glusterd
 %endif
 %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
 mkdir -p %{buildroot}%{_localstatedir}/log/glusterfs
 mkdir -p %{buildroot}%{_localstatedir}/log/glusterfsd
@@ -806,17 +896,11 @@ 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
@@ -828,13 +912,24 @@ sed -i 's|option working-directory /etc/glusterd|option working-directory %{_sha
 %endif
 
 # Install glusterfsd .service or init.d file
+%if ( 0%{!?_without_server:1} )
 %if ( 0%{_for_fedora_koji_builds} )
 %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
@@ -867,10 +962,8 @@ touch %{buildroot}%{_sharedstatedir}/glusterd/nfs/run/nfs.pid
 find ./tests ./run-tests.sh -type f | cpio -pd %{buildroot}%{_prefix}/share/glusterfs
 
 ## Install bash completion for cli
-%if ( 0%{!?_without_server:1} )
 install -p -m 0744 -D extras/command-completion/gluster.bash \
     %{buildroot}%{_sysconfdir}/bash_completion.d/gluster
-%endif
 
 %clean
 rm -rf %{buildroot}
@@ -887,29 +980,46 @@ rm -rf %{buildroot}
 %endif
 exit 0
 
-%post api
-/sbin/ldconfig
-
 %if ( 0%{!?_without_events:1} )
 %post events
 %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
     %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} )
@@ -1029,32 +1139,62 @@ 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 )
 %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
 ##
@@ -1065,9 +1205,6 @@ exit 0
 %exclude %{_mandir}/man8/gluster.8*
 %endif
 %dir %{_localstatedir}/log/glusterfs
-%if ( 0%{!?_without_rdma:1} )
-%exclude %{_libdir}/glusterfs/%{version}%{?prereltag}/rpc-transport/rdma*
-%endif
 %if 0%{?!_without_server:1}
 %dir %{_datadir}/glusterfs
 %dir %{_datadir}/glusterfs/scripts
@@ -1089,11 +1226,6 @@ exit 0
      %{_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
@@ -1121,54 +1253,54 @@ exit 0
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/nl-cache.so
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/system
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/system/posix-acl.so
-%if 0%{?!_without_server:1}
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/fdl.so
-%endif
 %dir %attr(0775,gluster,gluster) %{_rundir}/gluster
 %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
 
-%if ( 0%{!?_without_server:1} )
 %files cli
 %{_sbindir}/gluster
 %{_mandir}/man8/gluster.8*
 %{_sysconfdir}/bash_completion.d/gluster
-%endif
 
-%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
@@ -1176,25 +1308,13 @@ exit 0
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/cluster/*.so
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/protocol
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/protocol/client.so
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/dht2c.so
 
 %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.
@@ -1208,15 +1328,6 @@ 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
-
-%files cloudsync-plugins
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/cloudsync-plugins
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/cloudsync-plugins/cloudsyncs3.so
 
 %if ( 0%{?_with_gnfs:1} && 0%{!?_without_server:1} )
 %files gnfs
@@ -1229,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
@@ -1240,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
@@ -1256,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 python2-gluster
+%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 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
@@ -1293,6 +1429,19 @@ 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
@@ -1304,6 +1453,7 @@ exit 0
 %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
@@ -1326,7 +1476,7 @@ exit 0
 
 # 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
@@ -1337,18 +1487,12 @@ exit 0
 %{_mandir}/man8/gluster-setgfid2path.8*
 
 # xlators
-     %{_libdir}/libposix2common.so
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/arbiter.so
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/thin-arbiter.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/bit-rot.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/bitrot-stub.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/sdfs.so
-%if ( 0%{!?_without_tiering:1} )
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/changetimerecorder.so
-     %{_libdir}/libgfdb.so.*
-%endif
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/index.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/locks.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/posix*
@@ -1364,16 +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
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/jbrc.so
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/jbr.so
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/dht2s.so
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/posix2-ds.so
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/experimental/posix2-mds.so
 
 # snap_scheduler
 %{_sbindir}/snap_scheduler.py
@@ -1390,6 +1525,8 @@ exit 0
             %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
@@ -1398,6 +1535,7 @@ 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/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
@@ -1460,9 +1598,6 @@ exit 0
 %if ( 0%{?_with_firewalld:1} )
 %{_prefix}/lib/firewalld/services/glusterfs.xml
 %endif
-
-%{_sbindir}/gf_logdump
-%{_sbindir}/gf_recon
 # end of server files
 %endif
 
@@ -1473,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
@@ -1486,6 +1621,54 @@ 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)
 
@@ -1547,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 3286e639bcf..a0a778158d8 100644
--- a/glusterfsd/src/Makefile.am
+++ b/glusterfsd/src/Makefile.am
@@ -6,7 +6,7 @@ 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
@@ -14,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
 
@@ -21,6 +22,7 @@ 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 \
diff --git a/glusterfsd/src/gf_attach.c b/glusterfsd/src/gf_attach.c
index 1c1106c06f6..c553b0b1f61 100644
--- a/glusterfsd/src/gf_attach.c
+++ b/glusterfsd/src/gf_attach.c
@@ -12,202 +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,
 };
 
 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, NULL, 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 e7df714064a..0cdbffa71ea 100644
--- a/glusterfsd/src/glusterfsd-messages.h
+++ b/glusterfsd/src/glusterfsd-messages.h
@@ -11,7 +11,7 @@
 #ifndef _GLUSTERFSD_MESSAGES_H_
 #define _GLUSTERFSD_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.
  *
@@ -23,46 +23,71 @@
  * glfs-message-id.h.
  */
 
-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
-);
+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 df9a05c75f0..eaf6796e4c3 100644
--- a/glusterfsd/src/glusterfsd-mgmt.c
+++ b/glusterfsd/src/glusterfsd-mgmt.c
@@ -13,10 +13,10 @@
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
-#include "dict.h"
-#include "gf-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"
@@ -28,2821 +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 "monitoring.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);
+    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;
+    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_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;
-                                }
-                        }
+    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 (!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);
-
-        }
+        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;
-        }
-        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;
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Couldn't get "
+                   "xlator %s ",
+                   key);
+            goto out;
         }
-        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;
-        if (!active) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, EAGAIN, glusterfsd_msg_38,
-                        "Not processing brick-op no. %d since volume graph is "
-                        "not yet active.", xlator_req.op);
-                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;
-        }
+    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 (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;
+    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;
-        }
-
-        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,
-                        "rpc req buffer unserialization failed.");
-                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,
-                        "problem in xlator loading.");
-                goto out;
-        }
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                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);
         }
-
-        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,
-                        "failed to get dict value");
-                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;
-        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;
-
-        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;
-                                }
-                                /* 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);
-                        }
-                } else {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "got attach for %s but no active graph",
-                                xlator_req.name);
-                }
-                if (ret) {
-                        ret = -1;
-                }
-
-                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_dump_metrics (rpcsvc_request_t *req)
+glusterfs_handle_dump_metrics(rpcsvc_request_t *req)
 {
-        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_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        LG_MSG_NO_MEMORY,
-                        "Allocated size exceeds expectation: "
-                        "reconsider logic (%"GF_PRI_SIZET")",
-                        statbuf.st_size);
-        }
-        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;
+    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 (fd >= 0)
-                sys_close (fd);
+    if (fd >= 0)
+        sys_close(fd);
 
-        GF_FREE (msg);
-        GF_FREE (filepath);
+    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;
+    return ret;
 }
 
 int
-glusterfs_handle_defrag (rpcsvc_request_t *req)
+glusterfs_handle_defrag(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;
-        }
+    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 = xlator->notify(xlator, GF_EVENT_VOLUME_DEFRAG, dict, output);
 
-        ret = glusterfs_translator_info_response_send (req, ret,
-                                                       msg, output);
+    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;
-
+    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_brick_status (rpcsvc_request_t *req)
+glusterfs_handle_brick_status(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                *server_xl = NULL;
-        xlator_t                *brick_xl = NULL;
-        dict_t                  *dict = NULL;
-        dict_t                  *output = NULL;
-        char                    *xname = 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;
-        }
+    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;
 
-        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;
+    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;
 
-        brick_xl = get_xlator_by_name (server_xl, brickname);
-        if (!brick_xl) {
-                gf_log (this->name, GF_LOG_ERROR, "xlator %s is not loaded",
-                        xname);
-                ret = -1;
-                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:
-                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;
-
-                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;
-        }
+    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);
-        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);
+    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_node_status (rpcsvc_request_t *req)
+glusterfs_handle_node_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;
-        }
+    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 (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");
+            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_uint32 (dict, "cmd", &cmd);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get status op");
-                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;
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get volname");
-                goto out;
-        }
+        case GF_CLI_STATUS_FD:
+            // cannot find fd-tables in nfs-server graph
+            // TODO: finish once found
+            break;
 
-        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;
-        }
+        case GF_CLI_STATUS_CALLPOOL:
+            ret = 0;
+            gf_proc_dump_pending_frames_to_dict(ctx->pool, output);
+            break;
 
-        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;
-        }
+        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 = "";
 
-        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;
-        }
+    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;
+    }
 
-        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, NULL);
-                        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;
-        }
-
-        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);
+    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_nfs_profile (rpcsvc_request_t *req)
+glusterfs_handle_nfs_profile(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;
-        }
-
-        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;
-        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;
-        }
+    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;
+    }
 
-        output = dict_new ();
-        ret = subvol->notify (subvol, GF_EVENT_TRANSLATOR_INFO, dict, output);
+    output = dict_new();
+    ret = subvol->notify(subvol, GF_EVENT_TRANSLATOR_INFO, dict, output);
 
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        rsp.op_errstr = "";
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    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;
+    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_volume_barrier_op (rpcsvc_request_t *req)
+glusterfs_handle_volume_barrier_op(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;
-        }
+    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_BARRIER_OP,
-                              dict, output);
+    ret = xlator->notify(xlator, GF_EVENT_VOLUME_BARRIER_OP, dict, output);
 
-        ret = glusterfs_translator_info_response_send (req, ret,
-                                                       msg, output);
+    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;
-
+    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_barrier (rpcsvc_request_t *req)
+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;
-        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;
-
-        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;
-        }
+    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},
-
-        [GLUSTERD_DUMP_METRICS]        = {"DUMP METRICS",
-                                          GLUSTERD_DUMP_METRICS,
-                                          glusterfs_handle_dump_metrics,
-                                          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, };
-        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;
-        }
+    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;
+    }
 
-        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;
-        }
+    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;
+    }
 
-        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;
-        }
+    gf_log(frame->this->name, GF_LOG_INFO,
+           "Received list of available volfile servers: %s", servers_list);
 
-        if (!rsp.xdata.xdata_len) {
-                goto volfile;
-        }
+    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);
+    }
 
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+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)
+        {
+            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;
+            }
         }
 
-        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;
+        /* 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;
         }
-        dict->extra_stdfree = rsp.xdata.xdata_val;
 
-        /* glusterd2 only */
-        ret = dict_get_str (dict, "servers-list", &servers_list);
-        if (ret) {
-                goto volfile;
+        /* 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;
         }
 
-        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);
+        tmpfp = fdopen(tmp_fd, "w+b");
+        if (!tmpfp) {
+            ret = -1;
+            goto out;
         }
 
-volfile:
-        ret = 0;
-        size = rsp.op_ret;
-
-        glusterfs_compute_sha256 ((const unsigned char *) rsp.spec, size,
-                                  sha256_hash);
-
-        volfile_id = frame->local;
-
-        LOCK (&ctx->volfile_lock);
-        {
-                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;
-                        }
-                }
-
-                /* coverity[secure_temp] mkstemp uses 0600 as the mode */
-                tmp_fd = mkstemp (template);
-                if (-1 == tmp_fd) {
-                        gf_msg (frame->this->name, GF_LOG_ERROR, 0,
-                                glusterfsd_msg_39,
-                                "Unable to create temporary file: %s",
-                                template);
-                        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_msg (frame->this->name, GF_LOG_INFO, 0,
-                                glusterfsd_msg_39,
-                                "Unable to delete temporary file: %s",
-                                template);
-                        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
-                 */
-
-                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 (ret < 0) {
-                        gf_log ("glusterfsd-mgmt",
-                                GF_LOG_DEBUG, "Reconfigure failed !!");
-                        goto out;
-                }
-
-                ret = glusterfs_process_volfp (ctx, tmpfp);
-                /* tmpfp closed */
-                tmpfp = NULL;
-                tmp_fd = -1;
-                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));
+        fwrite(rsp.spec, size, 1, tmpfp);
+        fflush(tmpfp);
+        if (ferror(tmpfp)) {
+            ret = -1;
+            goto out;
         }
-        UNLOCK (&ctx->volfile_lock);
 
-        locked = 0;
+        /*  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 (!is_mgmt_rpc_reconnect) {
-                need_emancipate = 1;
-                glusterfs_mgmt_pmap_signin (ctx);
-                is_mgmt_rpc_reconnect =  _gf_true;
+        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;
         }
 
-out:
-
-        if (locked)
-                UNLOCK (&ctx->volfile_lock);
-
-        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;
 
-        if (dict)
-                dict_unref (dict);
+        if (!volfile_tmp) {
+            volfile_tmp = GF_CALLOC(1, sizeof(gf_volfile_t),
+                                    gf_common_volfile_t);
+            if (!volfile_tmp) {
+                ret = -1;
+                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);
+            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);
 
-        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);
-        }
+    locked = 0;
 
+post_graph_mgmt:
+    if (!is_mgmt_rpc_reconnect) {
+        need_emancipate = 1;
+        glusterfs_mgmt_pmap_signin(ctx);
+        is_mgmt_rpc_reconnect = _gf_true;
+    }
 
-        if (tmpfp)
-                fclose (tmpfp);
-        else if (tmp_fd != -1)
-                sys_close (tmp_fd);
+out:
 
-        return 0;
+    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;
-                if (!volfile_id) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "No volfile-id provided, erroring out");
-                        return -1;
-                }
-        }
-
-        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;
         }
+    }
 
-        /* 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_log(THIS->name, GF_LOG_ERROR, "Failed to serialize dictionary");
+        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 = 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;
-
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
+    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;
 
-        frame = create_frame (THIS, ctx->pool);
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
 
-        req.op = GF_EN_DEFRAG_STATUS;
+    frame = create_frame(THIS, ctx->pool);
 
-        if (dict) {
-                ret = dict_set_str (dict, "volname", cmd_args->volfile_id);
-                if (ret)
-                        gf_log ("", GF_LOG_ERROR, "failed to set volname");
+    req.op = GF_EN_DEFRAG_STATUS;
 
-                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:
-                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_t *cmd_args = NULL;
+    rpcsvc_t *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
 
-        cmd_args = &ctx->cmd_args;
+    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, _gf_false);
-        if (ret) {
-                goto out;
-        }
-
-        ctx->listener = rpc;
-
-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;
-
-        host = cmd_args->volfile_server;
-
-        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;
+    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;
 
-        /* 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;
+    options = dict_new();
+    if (!options)
+        goto out;
 
-                }
+    LOCK_INIT(&ctx->volfile_lock);
 
-                ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
+    if (cmd_args->volfile_server_port)
+        port = cmd_args->volfile_server_port;
 
-        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;
-        }
+    host = cmd_args->volfile_server;
 
-        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;
-        }
+    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 = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, 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 callback function");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set 'transport.socket.ssl-enabled' "
+                   "in options dict");
+            goto out;
         }
 
-        ctx->notify = glusterfs_mgmt_notify;
+        ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
 
-        /* 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);
+    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;
-
-        ctx = glusterfsd_ctx;
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
+    pmap_signin_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        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;
-        }
+    ctx = glusterfsd_ctx;
+    frame = myframe;
 
-        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;
-        }
+    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;
-        }
+    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;
+    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;
+    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;
+    return 0;
 
 out:
-        if (need_emancipate && (ret < 0 || !cmd_args->brick_port2))
-                emancipate (ctx, emancipate_ret);
+    if (need_emancipate && (ret < 0 || !cmd_args->brick_port2))
+        emancipate(ctx, emancipate_ret);
 
-        STACK_DESTROY (frame->root);
-        return 0;
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 int
-glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx)
+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;
+    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);
+            }
         }
+    }
 
-        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;
-
-        req.port  = cmd_args->brick_port;
-
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_pmap_prog,
-                                   GF_PMAP_SIGNIN, mgmt_pmap_signin_cbk,
-                                   (xdrproc_t)xdr_pmap_signin_req);
+    /* unfortunately, the caller doesn't care about the returned value */
 
 out:
-        if (need_emancipate && ret < 0)
-                emancipate (ctx, emancipate_ret);
-        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 d4b3a1139ad..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,1489 +47,1408 @@
 #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 "revision.h"
-#include "common-utils.h"
-#include "gf-event.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 "monitoring.h"
-
-#include "daemon.h"
+#include <glusterfs/monitoring.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"},
-        {"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"},
-
-        {"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"},
-        {"thin-client", ARGP_THIN_CLIENT_KEY, 0, 0,
-         "Enables thin mount and connects via gfproxyd daemon"},
-
-        {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)"},
-	{"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"},
-        {"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"},
-        {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 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_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                        glusterfsd_msg_1,
-                                        "Could not create absolute mountpoint "
-                                        "path");
-                                goto err;
-                        }
-                } else {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                glusterfsd_msg_2,
-                                "Could not get current working directory");
-                        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,
-                        "failed to set mount-point to options dictionary");
+    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, "failed to set dict value "
-                                "for key " 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,
-                                "failed to set dict value for key "
-                                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,
-                                "failed to set dict value for key "
-                                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,
-                                "failed to set dict value for key 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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set dict value for key "
-                                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,
-                                "failed to set dict value for key "
-                                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,
-                                "failed to set dict value for key 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,
-                                "failed to set dict value for key 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,
-                                "failed to set dict value for key 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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set dict value for key read-only");
-                        goto err;
-                }
-        }
+            }
+        } 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:
 
-	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,
-                                "failed to set dict value for key "
-				"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,
-                                "failed to set dict value for key "
-				"fopen-keep-cache");
-			goto err;
-		}
-		break;
-        case GF_OPTION_DEFERRED: /* default */
+            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,
-                                "failed to set dict value for key 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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set 'disable' for key "
-                                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,
-                                "failed to set 'enable' for key "
-                                ZR_DIRECT_IO_OPT);
-                        goto err;
-                }
-                break;
-        case GF_OPTION_DEFERRED: /* auto */
+            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,
-                                "failed to set 'enable' for key "
-                                "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,
-                                "failed to set 'disable' for key "
-                                "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,
-                                "failed to set dict value for key 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,
-                                "failed to set dict value for key "
-                                "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,
-                                "failed to set dict value for key "
-                                "event-history");
-                        goto err;
-                }
-        }
-        if (cmd_args->thin_client) {
-                ret = dict_set_static_ptr (options, "thin-client", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "thin-client");
-                        goto err;
-                }
-        }
-        if (cmd_args->reader_thread_count) {
-                ret = dict_set_uint32 (options, "reader-thread-count",
-                                       cmd_args->reader_thread_count);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "reader-thread-count");
-                        goto err;
-                }
-        }
-        switch (cmd_args->kernel_writeback_cache) {
+            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:
-                ret = dict_set_static_ptr(options, "kernel-writeback-cache",
-                        "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "kernel-writeback-cache");
-                        goto err;
-                }
-                break;
+            DICT_SET_VAL(dict_set_static_ptr, options, "kernel-writeback-cache",
+                         "on", glusterfsd_msg_3);
+            break;
         case GF_OPTION_DISABLE:
-                ret = dict_set_static_ptr(options, "kernel-writeback-cache",
-                        "off");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "kernel-writeback-cache");
-                        goto err;
-                }
-                break;
-        case GF_OPTION_DEFERRED: /* default */
+            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) {
-                ret = dict_set_uint32 (options, "attr-times-granularity",
-                                       cmd_args->attr_times_granularity);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "attr-times-granularity");
-                        goto err;
-                }
-        }
-
-
-        ret = 0;
+            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,
-                        "Not a client process, not performing mount operation");
-                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,
-                        "MOUNT-POINT %s initialization failed",
-                        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,
-                                "failed to set dict value for key "
-                                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,
-                        "loading volume file %s failed", cmd_args->volfile);
-                return NULL;
-        }
-
-        if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
-                        "loading volume file %s failed", 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;
-
-        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));
-        }
+    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:
-        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,
-                        "xlator option %s is invalid", 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,
-                        "xlator option %s is invalid", 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,
-                        "xlator option %s is invalid", 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_PRINT_XLATORDIR_KEY:
-                cmd_args->print_xlatordir = _gf_true;
-                break;
+            cmd_args->print_xlatordir = _gf_true;
+            break;
 
         case ARGP_PRINT_STATEDUMPDIR_KEY:
-                cmd_args->print_statedumpdir = _gf_true;
-                break;
+            cmd_args->print_statedumpdir = _gf_true;
+            break;
 
         case ARGP_PRINT_LOGDIR_KEY:
-                cmd_args->print_logdir = _gf_true;
-                break;
+            cmd_args->print_logdir = _gf_true;
+            break;
 
-        case ARGP_MAC_COMPAT_KEY:
-                if (!arg)
-                        arg = "on";
+        case ARGP_PRINT_LIBEXECDIR_KEY:
+            cmd_args->print_libexecdir = _gf_true;
+            break;
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->mac_compat = b;
+        case ARGP_MAC_COMPAT_KEY:
+            if (!arg)
+                arg = "on";
 
-                        break;
-                }
+            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;
-
-                if (gf_string2uint_base10 (arg, &n) == 0) {
-                        cmd_args->volfile_server_port = n;
-                        break;
-                }
+            n = 0;
 
-                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;
+            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;
-                }
-
-                if (strcmp (arg, "auto") == 0)
-                        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;
+
+            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;
-        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 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;
+            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;
-        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;
+            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 (!arg)
+                arg = "yes";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->kernel_writeback_cache = b;
-
-                        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);
-                }
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->kernel_writeback_cache = b;
 
                 break;
+            }
 
-	}
-        return 0;
+            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,
-                          "received signum (%d), shutting down", 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;
-                        rpc_clnt_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 {
-                rpc_clnt_mgmt_pmap_signout (ctx, NULL);
+            rpc_clnt_mgmt_pmap_signout(ctx, NULL);
         }
 
         /* below part is a racy code where the rpcsvc object is freed.
@@ -1548,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 */
@@ -1565,298 +1484,306 @@ cleanup_and_exit (int signum)
 
         trav = NULL;
 
+        /* 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,
-                        "Fetching the volume file from server...");
-                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,
-                        "volume initialization failed.");
+    /* 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,
-                       "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"
-         */
-        ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    struct rlimit lim = {
+        0,
+    };
+    int ret = -1;
 
-        /* monitoring should be enabled by default */
-        ctx->measure_latency = true;
-
-        ctx->process_uuid = generate_glusterfs_ctx_id ();
-        if (!ctx->process_uuid) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13,
-                        "ERROR: glusterfs uuid generation failed");
-                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,
-                        "ERROR: glusterfs iobuf pool creation failed");
-                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,
-                        "ERROR: glusterfs event pool creation failed");
-                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,
-                        "ERROR: glusterfs call pool creation failed");
-                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,
-                        "ERROR: glusterfs frame pool creation failed");
-                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,
-                        "ERROR: glusterfs stack pool creation failed");
-                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,
-                        "ERROR: glusterfs stub pool creation failed");
-                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_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;
-        cmd_args->kernel_writeback_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 (ctx, 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;
         }
+    }
 }
 
 /**
@@ -1874,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
@@ -1972,809 +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;
-        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 ();
-        }
-
-        argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
-
-        if (cmd_args->print_xlatordir || cmd_args->print_statedumpdir ||
-            cmd_args->print_logdir) {
-                /* 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;
-        }
-
-        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;
+    }
 
-        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_msg ("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15,
-                        "ERROR: '--volfile-id' is mandatory if '-s' OR "
-                        "'--volfile-server' option is given");
-                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,
-                                "ERROR: parsing the volfile failed");
-                        /* argp_usage (argp.) */
-                        fprintf (stderr, "USAGE: %s [options] [mountpoint]\n",
-                                 argv[0]);
-                        goto out;
-                }
-        }
+            GF_FREE(cmd_args->log_file);
+            cmd_args->log_file = gf_strdup(tmp_logfile);
 
-        if (cmd_args->thin_client) {
-                len = strlen (cmd_args->volfile_id) + strlen ("gfproxy-client/");
-                thin_volfileid = GF_CALLOC (1, 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;
+            GF_FREE(tmp_logfile_dyn);
         }
+    }
 
-        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 (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,
-                        "obsolete option '--volfile-max-fecth-attempts or "
-                        "fetch-attempts' was provided");
-        }
+    /*
+       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,
-                        "pidfile %s open failed", 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, pid_t pid)
+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,
-                        "pidfile %s lock failed", 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,
-                        "pidfile %s truncation failed", 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", pid);
-        if (ret <= 0) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
-                        "pidfile %s write failed", 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,
-                        "pidfile %s write failed", 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, pid);
+    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;
-        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);
-
-                        /* Nothing needed to be done here */
-                        GF_FREE (file);
-
-                        break;
-                default:
-
-                        break;
-                }
+    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);
+
+                /* Nothing needed to be done here */
+                GF_FREE(file);
+
+                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);
-
-        ret = pthread_sigmask (SIG_BLOCK, &set, NULL);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22,
-                        "failed to execute pthread_sigmask");
-                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,
-                        "failed to create pthread");
-                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;
-        int            child_pid = 0;
-
-        cmd_args = &ctx->cmd_args;
-
-        ret = glusterfs_pidfile_setup (ctx);
-        if (ret)
-                goto out;
-
-        if (cmd_args->no_daemon_mode) {
-                ret = glusterfs_pidfile_update (ctx, getpid());
-                if (ret)
-                        goto out;
-                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,
-                        "daemonization failed");
-                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 */
-                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_msg ("daemonize", GF_LOG_ERROR, 0,
-                                        glusterfsd_msg_25, "mount failed");
-                                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));
-                ret = glusterfs_pidfile_update (ctx, child_pid);
+            /* 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);
-        }
+                    exit(1);
+            }
+            _exit(0);
+    }
 
 postfork:
-        ret = gf_log_inject_timer_event (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;
+    }
+    gf_log("glusterfs", GF_LOG_INFO, "Pid of current running process is %d",
+           getpid());
+    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;
-
-        graph = glusterfs_graph_construct (fp);
-        if (!graph) {
-                gf_msg ("", GF_LOG_ERROR, 0, glusterfsd_msg_26,
-                        "failed to construct the graph");
-                goto out;
-        }
+    glusterfs_graph_t *graph = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
 
-        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,
-                                "fuse xlator cannot be specified in volume "
-                                "file");
-                        goto out;
-                }
-        }
+    if (!ctx)
+        return -1;
 
-        xlator_t *xl = graph->first;
-        if (strcmp (xl->type, "protocol/server") == 0) {
-                (void) copy_opts_to_child (xl, FIRST_CHILD (xl), "*auth*");
-        }
+    graph = glusterfs_graph_construct(fp);
+    if (!graph) {
+        gf_smsg("", GF_LOG_ERROR, 0, glusterfsd_msg_26, NULL);
+        goto out;
+    }
 
-        ret = glusterfs_graph_prepare (graph, ctx, ctx->cmd_args.volume_name);
-        if (ret) {
-                goto out;
+    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_activate (graph, ctx);
+    xlator_t *xl = graph->first;
+    if (xl && (strcmp(xl->type, "protocol/server") == 0)) {
+        (void)copy_opts_to_child(xl, FIRST_CHILD(xl), "*auth*");
+    }
 
-        if (ret) {
-                goto out;
-        }
+    ret = glusterfs_graph_prepare(graph, ctx, ctx->cmd_args.volume_name);
+    if (ret) {
+        goto out;
+    }
 
-        gf_log_dump_graph (fp, graph);
+    ret = glusterfs_graph_activate(graph, ctx);
 
-        ret = 0;
+    if (ret) {
+        goto out;
+    }
+
+    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,
-                        "Cannot reach volume specification file");
-                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);
-
-	ctx = glusterfs_ctx_new ();
-        if (!ctx) {
-                gf_msg ("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29,
-                        "ERROR: glusterfs context not initialized");
-                return ENOMEM;
-        }
-	glusterfsd_ctx = ctx;
-
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                return ret;
-
-	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;
+    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;
 
-        if (cmd->print_xlatordir) {
-                /* XLATORDIR passed through a -D flag to GCC */
-                printf ("%s\n", XLATORDIR);
-                goto out;
-        }
+    THIS->ctx = ctx;
 
-        if (cmd->print_statedumpdir) {
-                printf ("%s\n", DEFAULT_VAR_RUN_DIRECTORY);
-                goto out;
-        }
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-        if (cmd->print_logdir) {
-                printf ("%s\n", DEFAULT_LOG_FILE_DIRECTORY);
-                goto out;
-        }
+    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);
+    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);
 
-        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;
-        }
+        ctx->cmdlinestr = gf_strdup(cmdlinestr);
+    }
 
-        ret = logging_init (ctx, argv[0]);
-        if (ret)
-                goto out;
+    gf_proc_dump_init();
 
+    ret = create_fuse_mount(ctx);
+    if (ret)
+        goto out;
 
-        /* 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,
-                        "Started running %s version %s (args: %s)",
-                        argv[0], PACKAGE_VERSION, cmdlinestr);
+    ret = daemonize(ctx);
+    if (ret)
+        goto out;
 
-		ctx->cmdlinestr = gf_strdup (cmdlinestr);
-        }
+    /*
+     * 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();
 
-        gf_proc_dump_init();
-
-        ret = create_fuse_mount (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_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,
-                        "Could not create new sync-environment");
-                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 496a4d95352..4e1413caa70 100644
--- a/glusterfsd/src/glusterfsd.h
+++ b/glusterfsd/src/glusterfsd.h
@@ -13,125 +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_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_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_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
-xlator_mem_cleanup (xlator_t *this);
+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 f04a294cc56..aa18d3eff88 100644
--- a/heal/src/Makefile.am
+++ b/heal/src/Makefile.am
@@ -1,5 +1,6 @@
 if WITH_SERVER
-sbin_PROGRAMS = glfsheal
+scriptdir = $(GLUSTERFS_LIBEXECDIR)
+script_PROGRAMS = glfsheal
 endif
 
 glfsheal_SOURCES = glfs-heal.c
@@ -18,8 +19,7 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) \
 	-I$(top_srcdir)/rpc/xdr/src\
 	-I$(top_builddir)/rpc/xdr/src\
 	-I$(top_srcdir)/api/src\
-	-DDATADIR=\"$(localstatedir)\" \
-	-DSBIN_DIR=\"$(sbindir)\"
+	-DDATADIR=\"$(localstatedir)\"
 
 AM_CFLAGS = -Wall $(GF_CFLAGS) $(XML_CFLAGS)
 
diff --git a/heal/src/glfs-heal.c b/heal/src/glfs-heal.c
index 176ba6e44de..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,1484 +26,1456 @@
 #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)
+
+#define MODE_XML (1 << 0)
+#define MODE_NO_LOG (1 << 1)
 
 typedef struct num_entries {
-        uint64_t num_entries;
-        uint64_t pending_entries;
-        uint64_t spb_entries;
-        uint64_t possibly_healing_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);
+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);
+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);
-        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);
+    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 | info-summary] [glusterd-sock <FILE>"\
-                  "]\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 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;
+    /* 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;
 }
 
 int
-glfsh_print_hr_spb_status (char *path, uuid_t gfid, char *status)
+glfsh_print_hr_spb_status(char *path, uuid_t gfid, char *status)
 {
-        printf ("%s\n", path);
-        fflush (stdout);
-        return 0;
+    printf("%s\n", path);
+    fflush(stdout);
+    return 0;
 }
 
 int
-glfsh_no_print_hr_status (char *path, uuid_t gfid, char *status)
+glfsh_no_print_hr_status(char *path, uuid_t gfid, char *status)
 {
-        return 0;
+    return 0;
 }
 
 int
-glfsh_print_hr_heal_status (char *path, uuid_t gfid, char *status)
+glfsh_print_hr_heal_status(char *path, uuid_t gfid, char *status)
 {
-        printf ("%s%s\n", path, status);
-        fflush (stdout);
-        return 0;
+    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> */
-        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);
+    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", "");
-        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);
+    } 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)
 {
-        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);
-                }
-                goto out;
-        } else if (ret == 0) {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                                 (xmlChar *)"status",
-                                                 "%s", "Connected");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
+    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) {
-                        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);
-                }
+        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:
+    if (x_ret >= 0) {
+        x_ret = xmlTextWriterEndElement(glfsh_writer);
         if (x_ret >= 0) {
-                x_ret = xmlTextWriterEndElement (glfsh_writer);
-                if (x_ret >= 0) {
-                        xmlTextWriterFlush (glfsh_writer);
-                        x_ret = 0;
-                } else {
-                        x_ret = -1;
-                }
+            xmlTextWriterFlush(glfsh_writer);
+            x_ret = 0;
+        } else {
+            x_ret = -1;
         }
-        return x_ret;
+    }
+    return x_ret;
 }
 
 int
-glfsh_print_xml_heal_op_summary (int ret, num_entries_t *num_entries)
+glfsh_print_xml_heal_op_summary(int ret, num_entries_t *num_entries)
 {
-        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);
-        }
+    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;
+    if (x_ret >= 0) {
+        x_ret = xmlTextWriterEndElement(glfsh_writer);
+    }
+    return x_ret;
 }
 
 int
-glfsh_print_xml_file_status (char *path, uuid_t gfid, char *status)
+glfsh_print_xml_file_status(char *path, uuid_t gfid, char *status)
 {
-        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);
+    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;
+    return x_ret;
 }
 
 int
-glfsh_print_xml_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+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;
+    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_summary (int ret, num_entries_t *num_entries)
+glfsh_print_hr_heal_op_summary(int ret, num_entries_t *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);
-        }
+    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");
-        fflush (stdout);
-        return 0;
+    printf("\n");
+    fflush(stdout);
+    return 0;
 }
 
 int
-glfsh_print_hr_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_print_hr_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        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 == 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;
+    printf("\n");
+    return 0;
 }
 
 int
-glfsh_print_info_summary (int ret, num_entries_t *num_entries)
+glfsh_print_info_summary(int ret, num_entries_t *num_entries)
 {
-        return glfsh_output->print_heal_op_summary (ret, num_entries);
-
+    return glfsh_output->print_heal_op_summary(ret, num_entries);
 }
 
 int
-glfsh_print_heal_op_status (int ret, uint64_t num_entries,
-                            gf_xl_afr_op_t heal_op)
+glfsh_print_heal_op_status(int ret, uint64_t num_entries,
+                           gf_xl_afr_op_t heal_op)
 {
-        char *fmt_str = NULL;
+    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 (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:";
 
-        return glfsh_output->print_heal_op_status (ret, num_entries, fmt_str);
+    return glfsh_output->print_heal_op_status(ret, num_entries, fmt_str);
 }
 
 int
-glfsh_get_index_dir_loc (loc_t *rootloc, xlator_t *xl, loc_t *dirloc,
-                         int32_t *op_errno, char *vgfid)
+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;
+    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;
-
-        if (heal_op == GF_SHD_OP_INDEX_SUMMARY ||
-            heal_op == GF_SHD_OP_HEAL_SUMMARY)
-                ancestors = heal_xls;
-        else
-                ancestors = replica_xl;
+    static char *replica_xl[] = {"cluster/replicate", NULL};
+    static char *heal_xls[] = {"cluster/replicate", "cluster/disperse", NULL};
+    char **ancestors = 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;
-        }
+    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;
+
+    while (xl->parents) {
+        xl = xl->parents->xlator;
+        if (!xl)
+            break;
+        if (gf_get_index_by_elem(ancestors, xl->type) != -1)
+            return xl;
+    }
+
+    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_summary_status (dict_t *dict, char *path, uuid_t gfid,
-                            num_entries_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;
-        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)++;
+    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;
+    return ret;
 }
 
 int
-glfsh_print_spb_status (dict_t *dict, char *path, uuid_t gfid,
-                        num_entries_t *num_entries, gf_boolean_t flag)
+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;
+    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->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,
-                         num_entries_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");
-                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;
-        }
+    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->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,
-                           num_entries_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 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)++;
-        }
+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, num_entries_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, num_entries_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_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;
-        }
+    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,
-                                num_entries_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;
-        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;
-
+    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;
-        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;
-
+    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;
 }
 
 static int
-glfsh_set_heal_options (glfs_t *fs, gf_xl_afr_op_t heal_op)
+glfsh_set_heal_options(glfs_t *fs, gf_xl_afr_op_t heal_op)
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*",
-                                      "background-self-heal-count", "0");
-        if (ret)
-                goto out;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*",
+                                 "background-self-heal-count", "0");
+    if (ret)
+        goto out;
 
-        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;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "halo-enabled", "off");
+    if (ret)
+        goto out;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "metadata-self-heal",
-                                      "on");
-        if (ret)
-                goto out;
+    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;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "entry-self-heal",
-                                      "on");
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "metadata-self-heal",
+                                 "on");
+    if (ret)
+        goto out;
+
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "entry-self-heal", "on");
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-glfsh_validate_volume (xlator_t *xl, gf_xl_afr_op_t heal_op)
+glfsh_validate_volume(xlator_t *xl, gf_xl_afr_op_t heal_op)
 {
-        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;
+    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;
+            }
         }
 
-        return ret;
+        xl = xl->prev;
+    }
+
+    return ret;
 }
 
-static xlator_t*
-_brick_path_to_client_xlator (xlator_t *top_subvol, char *hostname,
-                              char *brickpath)
+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;
+    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;
+    }
 
 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;
         }
-        ret = syncop_getxattr (xl, &loc, &xattr_rsp, GF_AFR_HEAL_SBRAIN,
-                               xattr_req, NULL);
+        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 ("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;
+        }
+        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, "sh-fail-msg", &sh_fail_msg);
+
+        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,
-                            num_entries_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;
-        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;
-
-                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;
-        }
+    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;
+
+        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.num_entries,
-                                            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 going to call fini
@@ -1516,270 +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_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
-};
+    .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_status,
-        .print_spb_status = glfsh_no_print_hr_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_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
-};
+    .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;
-        char      *socket_filepath = NULL;
-        gf_xl_afr_op_t heal_op = -1;
-
-        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;
-                }
+    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];
-        switch (argc) {
+    }
+    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;
+
+    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 if (!strcmp (argv[2], "info-summary")) {
-                        heal_op = GF_SHD_OP_HEAL_SUMMARY;
-                } 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], "info-summary")) &&
-                           (!strcmp (argv[3], "xml"))) {
-                        heal_op = GF_SHD_OP_HEAL_SUMMARY;
-                        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;
-                fs->ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
-        if (socket_filepath != NULL) {
-                ret = glfs_set_volfile_server (fs, "unix", socket_filepath, 0);
+    }
+
+    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 {
-                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;
+            gf_asprintf(&op_errstr,
+                        "%s: Not able to fetch "
+                        "volfile from glusterd",
+                        volname);
         }
-
-        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;
-        }
-
-        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 ||
-                                      heal_op == GF_SHD_OP_HEAL_SUMMARY) ?
-                                     "replicate/disperse":"replicate");
-                goto out;
-        }
-        rootloc.inode = inode_ref (top_subvol->itable->root);
-        ret = glfs_loc_touchup (&rootloc);
-        if (ret < 0) {
-                ret = -errno;
-                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));
         }
-
-        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:
         case GF_SHD_OP_HEAL_SUMMARY:
-                ret = glfsh_gather_heal_info (fs, top_subvol, &rootloc,
-                                              heal_op);
-                break;
+            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 e2ff1fb6214..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} -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 463e8becd3a..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}
-Requires: sqlite3 @PKGCONFIG_UUID@
diff --git a/xlators/experimental/dht2/dht2-client/Makefile.am b/libglusterd/Makefile.am
index a985f42a877..a985f42a877 100644
--- a/xlators/experimental/dht2/dht2-client/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 a910d8e8a53..385e8ef4600 100644
--- a/libglusterfs/src/Makefile.am
+++ b/libglusterfs/src/Makefile.am
@@ -6,14 +6,14 @@ 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)\" \
-	-DXXH_NAMESPACE=GF_ \
-	-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 = $(ZLIB_LIBS) $(MATH_LIB) $(UUID_LIBS)
+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
 
@@ -37,30 +37,36 @@ libglusterfs_la_SOURCES = dict.c xlator.c logging.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 monitoring.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 gf-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 monitoring.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
 
@@ -70,7 +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
+	$(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
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 ca7f919f0d1..00000000000
--- a/libglusterfs/src/atomic.h
+++ /dev/null
@@ -1,462 +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>
-#include <stdbool.h>
-
-#include "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/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 a1b87bf5db2..ee84f08acd4 100644
--- a/libglusterfs/src/call-stub.c
+++ b/libglusterfs/src/call-stub.c
@@ -11,2759 +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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    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)
+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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_FSTAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        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);
+    stub->fn_cbk.fstat = fn;
+    args_fstat_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
 out:
-        return stub;
+    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_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);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_TRUNCATE);
-        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.truncate = fn;
-        args_truncate_store (&stub->args, loc, 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,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-		       struct iatt *postbuf, dict_t *xdata)
+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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_TRUNCATE);
+    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.truncate = fn;
-        args_truncate_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_ftruncate_stub(call_frame_t *frame, fop_ftruncate_t fn, fd_t *fd, 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_FTRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, 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->fn.ftruncate = fn;
+    args_ftruncate_store(&stub->args, fd, off, 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_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 *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_FTRUNCATE);
-        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.ftruncate = fn;
+    args_ftruncate_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                             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_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);
+    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_ACCESS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.access = fn;
-        args_access_store (&stub->args, loc, mask, xdata);
+    stub->fn.access = fn;
+    args_access_store(&stub->args, loc, mask, 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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_ACCESS);
+    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.access = fn;
+    args_access_cbk_store(&stub->args_cbk, op_ret, op_errno, 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_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_READLINK);
-        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.readlink = fn;
-        args_readlink_store (&stub->args, loc, size, xdata);
+    stub->fn.readlink = fn;
+    args_readlink_store(&stub->args, loc, size, 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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_READLINK);
-        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.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_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_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_MKNOD);
-        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.mknod = fn;
-        args_mknod_store (&stub->args, loc, mode, rdev, umask, xdata);
+    stub->fn.mknod = fn;
+    args_mknod_store(&stub->args, loc, mode, rdev, 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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_MKNOD);
-        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.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_mkdir_stub (call_frame_t *frame, fop_mkdir_t fn,
-                loc_t *loc, mode_t mode, 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_MKDIR);
-        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.mkdir = fn;
-        args_mkdir_store (&stub->args, loc, mode, umask, 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,
-                    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_MKDIR);
-        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.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_unlink_stub (call_frame_t *frame, fop_unlink_t fn,
-                 loc_t *loc, int xflag, 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_UNLINK);
-        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.unlink = fn;
+    args_unlink_store(&stub->args, loc, xflag, 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_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_UNLINK);
-        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.unlink = fn;
-        args_unlink_cbk_store (&stub->args_cbk, op_ret, op_errno, 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_rmdir_stub (call_frame_t *frame, fop_rmdir_t fn,
-                loc_t *loc, int flags, 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_RMDIR);
-        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.rmdir = fn;
-        args_rmdir_store (&stub->args, loc, flags, xdata);
+    stub->fn.rmdir = fn;
+    args_rmdir_store(&stub->args, loc, flags, 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_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_RMDIR);
-        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.rmdir = fn;
-        args_rmdir_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_symlink_stub (call_frame_t *frame, fop_symlink_t fn,
-                  const char *linkname, loc_t *loc, mode_t umask, 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;
+    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", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", linkname, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SYMLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    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);
+    stub->fn.symlink = fn;
+    args_symlink_store(&stub->args, linkname, loc, umask, 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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_SYMLINK);
+    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.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_rename_stub (call_frame_t *frame, fop_rename_t fn,
-                 loc_t *oldloc, loc_t *newloc, 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", 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_RENAME);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.rename = fn;
-        args_rename_store (&stub->args, oldloc, newloc, xdata);
+    stub->fn.rename = fn;
+    args_rename_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_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;
-
-        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_RENAME);
+    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.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_link_stub (call_frame_t *frame, fop_link_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_LINK);
-        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.link = fn;
-        args_link_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_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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_LINK);
+    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.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_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_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", 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_CREATE);
+    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.create = fn;
+    args_create_store(&stub->args, loc, flags, mode, umask, 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_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_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.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_open_stub (call_frame_t *frame, fop_open_t fn,
-               loc_t *loc, int32_t flags, 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_OPEN);
-        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.open = fn;
+    args_open_store(&stub->args, loc, flags, fd, 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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_OPEN);
-        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.open = fn;
+    args_open_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, 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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_READ);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READ);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readv = fn;
-        args_readv_store (&stub->args, fd, size, off, flags, xdata);
+    stub->fn.readv = fn;
+    args_readv_store(&stub->args, fd, size, off, flags, 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_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;
-
-        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_READ);
+    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.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_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_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);
+    GF_VALIDATE_OR_GOTO("call-stub", vector, out);
 
-        stub = stub_new (frame, 1, GF_FOP_WRITE);
-        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.writev = fn;
-        args_writev_store (&stub->args, fd, vector, count, off, flags,
-                           iobref, 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_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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_WRITE);
+    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.writev = fn;
-        args_writev_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                               prebuf, postbuf, 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_flush_stub (call_frame_t *frame, fop_flush_t fn,
-                fd_t *fd, 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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 1, GF_FOP_FLUSH);
+    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.flush = fn;
+    args_flush_store(&stub->args, fd, 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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_FLUSH);
+    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.flush = fn;
-        args_flush_cbk_store (&stub->args_cbk, op_ret, op_errno, 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_fsync_stub (call_frame_t *frame, fop_fsync_t fn,
-                fd_t *fd, int32_t datasync, 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_FSYNC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn.fsync = fn;
-        args_fsync_store (&stub->args, fd, datasync, xdata);
+    stub->fn.fsync = fn;
+    args_fsync_store(&stub->args, fd, datasync, 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_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_FSYNC);
-        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.fsync = fn;
-        args_fsync_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                              prebuf, postbuf, 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_opendir_stub (call_frame_t *frame, fop_opendir_t fn,
-                  loc_t *loc, fd_t *fd, 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);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_OPENDIR);
-        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.opendir = fn;
-        args_opendir_store (&stub->args, loc, fd, xdata);
+    stub->fn.opendir = fn;
+    args_opendir_store(&stub->args, loc, fd, 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_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_OPENDIR);
-        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.opendir = fn;
+    args_opendir_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, 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_fsyncdir_stub(call_frame_t *frame, fop_fsyncdir_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_FSYNCDIR);
+    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.fsyncdir = fn;
-        args_fsyncdir_store (&stub->args, fd, datasync, xdata);
+    stub->fn.fsyncdir = fn;
+    args_fsyncdir_store(&stub->args, fd, datasync, 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_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_FSYNCDIR);
-        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.fsyncdir = fn;
+    args_fsyncdir_cbk_store(&stub->args_cbk, op_ret, op_errno, 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_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);
+    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_STATFS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.statfs = fn;
-        args_statfs_store (&stub->args, loc, xdata);
+    stub->fn.statfs = fn;
+    args_statfs_store(&stub->args, loc, 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_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_STATFS);
-        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.statfs = fn;
-        args_statfs_cbk_store (&stub->args_cbk, op_ret, op_errno, buf, 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_setxattr_stub (call_frame_t *frame, fop_setxattr_t fn,
-                   loc_t *loc, dict_t *dict,
-                   int32_t flags, 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_SETXATTR);
-        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.setxattr = fn;
-        args_setxattr_store (&stub->args, loc, dict, flags, xdata);
+    stub->fn.setxattr = fn;
+    args_setxattr_store(&stub->args, loc, dict, flags, 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_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_SETXATTR);
-        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.setxattr = fn;
-        args_setxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, 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_getxattr_stub (call_frame_t *frame, fop_getxattr_t fn,
-                   loc_t *loc, const char *name, 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_GETXATTR);
-        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.getxattr = fn;
-        args_getxattr_store (&stub->args, loc, name, xdata);
+    stub->fn.getxattr = fn;
+    args_getxattr_store(&stub->args, loc, name, 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_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_GETXATTR);
-        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.getxattr = fn;
-        args_getxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, dict,
-                                 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_fsetxattr_stub (call_frame_t *frame, fop_fsetxattr_t fn,
-                    fd_t *fd, dict_t *dict, int32_t flags, 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", 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_FSETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsetxattr = fn;
-        args_fsetxattr_store (&stub->args, fd, dict, flags, xdata);
+    stub->fn.fsetxattr = fn;
+    args_fsetxattr_store(&stub->args, fd, dict, flags, 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_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_FSETXATTR);
-        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.fsetxattr = fn;
+    args_fsetxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, 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_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_FGETXATTR);
-        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.fgetxattr = fn;
-        args_fgetxattr_store (&stub->args, fd, name, xdata);
+    stub->fn.fgetxattr = fn;
+    args_fgetxattr_store(&stub->args, fd, 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_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_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.fgetxattr = fn;
+    args_fgetxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, dict, 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_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", loc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", name, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, 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_REMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.removexattr = fn;
-        args_removexattr_store (&stub->args, loc, name, xdata);
+    stub->fn.removexattr = fn;
+    args_removexattr_store(&stub->args, loc, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 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)
+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_REMOVEXATTR);
-        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.removexattr = fn;
+    args_removexattr_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_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", fd, 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_FREMOVEXATTR);
-        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.fremovexattr = fn;
-        args_fremovexattr_store (&stub->args, fd, name, xdata);
+    stub->fn.fremovexattr = fn;
+    args_fremovexattr_store(&stub->args, fd, name, 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_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_FREMOVEXATTR);
-        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.fremovexattr = fn;
+    args_fremovexattr_cbk_store(&stub->args_cbk, op_ret, op_errno, 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_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", 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_LK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lk = fn;
-        args_lk_store (&stub->args, fd, cmd, lock, xdata);
+    stub->fn.lk = fn;
+    args_lk_store(&stub->args, fd, 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_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_LK);
-        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.lk = fn;
+    args_lk_cbk_store(&stub->args_cbk, op_ret, op_errno, lock, 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_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_INODELK);
-        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.inodelk = fn;
-        args_inodelk_store (&stub->args, volume, loc, 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_inodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno, 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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_INODELK);
+    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.inodelk       = fn;
-        args_inodelk_cbk_store (&stub->args_cbk, op_ret, op_errno, 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_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", 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_FINODELK);
-        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.finodelk = fn;
-        args_finodelk_store (&stub->args, volume, fd, cmd,
-                             lock, xdata);
+    stub->fn.finodelk = fn;
+    args_finodelk_store(&stub->args, volume, fd, 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)
+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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_FINODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        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);
+    stub->fn_cbk.finodelk = fn;
+    args_finodelk_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_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, 1, GF_FOP_ENTRYLK);
-        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.entrylk = fn;
+    args_entrylk_store(&stub->args, volume, loc, name, cmd, type, 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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_ENTRYLK);
-        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_cbk.entrylk = fn;
+    args_entrylk_cbk_store(&stub->args_cbk, op_ret, op_errno, 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_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;
-
-        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_FENTRYLK);
+    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.fentrylk = fn;
+    args_fentrylk_store(&stub->args, volume, fd, name, cmd, type, 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_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_FENTRYLK);
-        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.fentrylk       = fn;
-        args_fentrylk_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_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_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, 0, GF_FOP_READDIRP);
-        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.readdirp = fn;
+    args_readdirp_cbk_store(&stub->args_cbk, op_ret, op_errno, entries, 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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_READDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        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);
+    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_readdir_stub (call_frame_t *frame, fop_readdir_t fn,
-                  fd_t *fd, size_t size,
-                  off_t off, 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;
 
-        stub = stub_new (frame, 1, GF_FOP_READDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readdir = fn;
-        args_readdir_store (&stub->args, fd, size, off, xdata);
+    stub->fn.readdir = fn;
+    args_readdir_store(&stub->args, fd, size, off, 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_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;
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_READDIRP);
-        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.readdirp = fn;
-        args_readdirp_store (&stub->args, fd, size, off, xdata);
+    stub->fn.readdirp = fn;
+    args_readdirp_store(&stub->args, fd, size, off, 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_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);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 1, GF_FOP_RCHECKSUM);
-        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.rchecksum = fn;
-        args_rchecksum_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.rchecksum = fn;
+    args_rchecksum_store(&stub->args, fd, offset, len, 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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_RCHECKSUM);
+    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.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_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_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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_XATTROP);
+    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.xattrop       = fn;
-        args_xattrop_cbk_store (&stub->args_cbk, op_ret, op_errno, xattr,
-                                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_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_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;
-        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);
+    stub = stub_new(frame, 0, GF_FOP_FXATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fxattrop = fn;
-        args_xattrop_cbk_store (&stub->args_cbk, op_ret, op_errno, xattr,
-                                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_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_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", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", xattr, out);
+    GF_VALIDATE_OR_GOTO("call-stub", xattr, out);
 
-        stub = stub_new (frame, 1, GF_FOP_XATTROP);
-        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.xattrop = fn;
-        args_xattrop_store (&stub->args, loc, optype, xattr, xdata);
+    stub->fn.xattrop = fn;
+    args_xattrop_store(&stub->args, loc, optype, xattr, 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_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", xattr, out);
+    GF_VALIDATE_OR_GOTO("call-stub", xattr, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FXATTROP);
-        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.fxattrop = fn;
-        args_fxattrop_store (&stub->args, fd, optype, xattr, xdata);
+    stub->fn.fxattrop = fn;
+    args_fxattrop_store(&stub->args, fd, optype, xattr, 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_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_SETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.setattr = fn;
-        args_setattr_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                statpost, 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)
+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;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_FSETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        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);
+    stub->fn_cbk.fsetattr = fn;
+    args_fsetattr_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                            statpost, 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_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);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETATTR);
-        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.setattr = fn;
-        args_setattr_store (&stub->args, loc, stbuf, valid, xdata);
+    stub->fn.setattr = fn;
+    args_setattr_store(&stub->args, loc, stbuf, valid, 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_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;
+    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_FSETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsetattr = fn;
-        args_fsetattr_store (&stub->args, fd, stbuf, valid, xdata);
+    stub->fn.fsetattr = fn;
+    args_fsetattr_store(&stub->args, fd, stbuf, valid, 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)
+                       int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, 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_FALLOCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fallocate = fn;
+    stub->fn_cbk.fallocate = fn;
 
-        args_fallocate_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                  statpost, xdata);
+    args_fallocate_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                             statpost, 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)
+                   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", 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_FALLOCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fallocate = fn;
-        args_fallocate_store (&stub->args, fd, mode, offset, len, xdata);
+    stub->fn.fallocate = fn;
+    args_fallocate_store(&stub->args, fd, mode, offset, len, 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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_DISCARD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_DISCARD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.discard = fn;
+    stub->fn_cbk.discard = fn;
 
-        args_discard_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_discard_stub(call_frame_t *frame, fop_discard_t fn, fd_t *fd,
-		 off_t offset, size_t len, 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);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_DISCARD);
-        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.discard = fn;
-        args_discard_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.discard = fn;
+    args_discard_store(&stub->args, fd, offset, len, 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)
+                      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_ZEROFILL);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ZEROFILL);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.zerofill = fn;
 
-        stub->fn_cbk.zerofill = fn;
-
-        args_zerofill_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                 statpost, xdata);
+    args_zerofill_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                            statpost, 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)
+                  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_ZEROFILL);
-        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.zerofill = fn;
-        args_zerofill_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.zerofill = fn;
+    args_zerofill_store(&stub->args, fd, offset, len, 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_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_IPC);
-        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.ipc = fn;
+    stub->fn_cbk.ipc = fn;
 
-        args_ipc_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    args_ipc_cbk_store(&stub->args_cbk, op_ret, op_errno, 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_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_IPC);
-        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.ipc = fn;
-        args_ipc_store (&stub->args, op, xdata);
+    stub->fn.ipc = fn;
+    args_ipc_store(&stub->args, op, xdata);
 out:
-        return stub;
+    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)
+{
+    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;
 }
 
 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_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;
+    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);
 
-        stub = stub_new (frame, 0, GF_FOP_LEASE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, 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);
+    stub->fn.lease = fn;
+    args_lease_store(&stub->args, loc, 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_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);
-        GF_VALIDATE_OR_GOTO ("call-stub", lease, out);
+    stub = stub_new(frame, 0, GF_FOP_SEEK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LEASE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.seek = fn;
 
-        stub->fn.lease = fn;
-        args_lease_store (&stub->args, loc, lease, xdata);
+    args_seek_cbk_store(&stub->args_cbk, op_ret, op_errno, offset, xdata);
 out:
-        return stub;
-
+    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_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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_SEEK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub->fn_cbk.seek = fn;
+    stub = stub_new(frame, 1, GF_FOP_SEEK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        args_seek_cbk_store (&stub->args_cbk, op_ret, op_errno, offset, xdata);
+    stub->fn.seek = fn;
+    args_seek_store(&stub->args, fd, offset, what, 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_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_SEEK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.getactivelk = fn;
 
-        stub->fn.seek = fn;
-        args_seek_store (&stub->args, fd, offset, what, xdata);
+    args_getactivelk_cbk_store(&stub->args_cbk, op_ret, op_errno, lmi, xdata);
 out:
-        return stub;
-
+    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_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", 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_GETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.getactivelk = fn;
+    stub->fn.getactivelk = fn;
 
-        args_getactivelk_cbk_store (&stub->args_cbk, op_ret, op_errno, lmi,
-                                    xdata);
+    loc_copy(&stub->args.loc, loc);
+
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_getactivelk_stub (call_frame_t *frame, fop_getactivelk_t fn, loc_t *loc,
-                      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;
-
-        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_SETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.getactivelk = fn;
+    stub->fn_cbk.setactivelk = fn;
+    stub->args_cbk.op_ret = op_ret;
+    stub->args_cbk.op_errno = op_errno;
 
-        loc_copy (&stub->args.loc, loc);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
-        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_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_SETACTIVELK);
-        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_cbk.setactivelk = fn;
-        stub->args_cbk.op_ret = op_ret;
-        stub->args_cbk.op_errno = op_errno;
+    stub->fn.setactivelk = fn;
 
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    args_setactivelk_store(&stub->args, loc, locklist, 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)
+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", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETACTIVELK);
-        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.setactivelk = fn;
+    stub->fn.copy_file_range = fn;
 
-        args_setactivelk_store (&stub->args, loc, locklist, xdata);
+    args_copy_file_range_store(&stub->args, fd_in, off_in, fd_out, off_out, len,
+                               flags, xdata);
 
 out:
-        return stub;
-
+    return stub;
 }
 
 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)
+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", vector, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_PUT);
-        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.copy_file_range = fn;
+    args_copy_file_range_cbk_store(&stub->args_cbk, op_ret, op_errno, stbuf,
+                                   prebuf_dst, postbuf_dst, 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)
+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", vector, out);
 
-        stub = stub_new (frame, 0, GF_FOP_PUT);
-        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_cbk.put = fn;
-        args_put_cbk_store (&stub->args_cbk, op_ret, op_errno, inode,
-                            buf, preparent, postparent, 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_icreate_stub (call_frame_t *frame, fop_icreate_t fn,
-                  loc_t *loc, mode_t mode, dict_t *xdata)
+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;
+    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_PUT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ICREATE);
-        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_icreate_stub(call_frame_t *frame, fop_icreate_t fn, loc_t *loc, mode_t mode,
+                 dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub->fn.icreate = fn;
+    stub = stub_new(frame, 1, GF_FOP_ICREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->args.mode = mode;
-        if (loc)
-                loc_copy (&stub->args.loc, loc);
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    stub->fn.icreate = fn;
 
- out:
-        return stub;
+    stub->args.mode = mode;
+    if (loc)
+        loc_copy(&stub->args.loc, loc);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
+
+out:
+    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_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);
+    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_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)
+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);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_ICREATE);
-        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_cbk.icreate = fn;
-        args_icreate_store_cbk (&stub->args_cbk,
-                                op_ret, op_errno, inode, buf, xdata);
+    stub->fn_cbk.icreate = fn;
+    args_icreate_store_cbk(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                           xdata);
 
- out:
-        return stub;
+out:
+    return stub;
 }
 
 call_stub_t *
-fop_namelink_stub (call_frame_t *frame,
-                   fop_namelink_t fn, loc_t *loc, 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);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_NAMELINK);
-        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.namelink = fn;
+    stub->fn.namelink = fn;
 
-        if (loc)
-                loc_copy (&stub->args.loc, loc);
-        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;
+out:
+    return stub;
 }
 
 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)
+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)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
+    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);
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(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)
+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;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_NAMELINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_NAMELINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.namelink = fn;
-        args_namelink_store_cbk (&stub->args_cbk,
-                                 op_ret, op_errno, prebuf, postbuf, xdata);
+    stub->fn_cbk.namelink = fn;
+    args_namelink_store_cbk(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
 
- out:
-        return stub;
+out:
+    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;
+            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;
+            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;
+    xlator_t *old_THIS = NULL;
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        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;
-
-        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;
+    xlator_t *old_THIS = NULL;
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        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;
+    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 c3b63d4c758..00000000000
--- a/libglusterfs/src/call-stub.h
+++ /dev/null
@@ -1,816 +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;
-        gf_boolean_t poison;
-        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;
-        } 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;
-	} 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);
-
-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);
-
-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 561ca04e48b..acdaed04ae2 100644
--- a/libglusterfs/src/checksum.c
+++ b/libglusterfs/src/checksum.c
@@ -22,24 +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 *sha256_md)
+gf_rsync_strong_checksum(unsigned char *data, size_t len,
+                         unsigned char *sha256_md)
 {
-        SHA256((const unsigned char *)data, len, sha256_md);
+    SHA256((const unsigned char *)data, len, sha256_md);
 }
 
 void
-gf_rsync_md5_checksum (unsigned char *data, size_t len, unsigned char *md5)
+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 046f72e021d..9d377c3c2e1 100644
--- a/libglusterfs/src/client_t.c
+++ b/libglusterfs/src/client_t.c
@@ -8,661 +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->call_cleanup && 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->client_name);
-        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->call_cleanup && 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;
-                        /* don't 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)
-{
-        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;
-}
-
-
-void
-client_dump (client_t *client, char *prefix)
-{
-        char key[GF_DUMP_MAX_BUF_LEN];
-
-        if (!client)
-                return;
-
-        memset(key, 0, sizeof key);
-        gf_proc_dump_write("refcount", GF_PRI_ATOMIC,
-                           GF_ATOMIC_GET (client->count));
-}
-
-
-void
-cliententry_dump (cliententry_t *cliententry, char *prefix)
+client_ctx_del(client_t *client, void *key, void **value)
 {
-        if (!cliententry)
-                return;
+    int ret = 0;
 
-        if (GF_CLIENTENTRY_ALLOCATED != cliententry->next_free)
-                return;
-
-        if (cliententry->client)
-                client_dump(cliententry->client, prefix);
-}
+    if (!client || !key)
+        return -1;
 
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_del_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
-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);
+    return ret;
 }
 
-
 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;
@@ -705,256 +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;
-                        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);
+    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 = 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);
-                                }
-                        }
+    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 66db3e86499..00000000000
--- a/libglusterfs/src/client_t.h
+++ /dev/null
@@ -1,139 +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;
-        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;
-} 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 aa9cea75ba3..6ee89ddfdcf 100644
--- a/libglusterfs/src/cluster-syncop.c
+++ b/libglusterfs/src/cluster-syncop.c
@@ -14,542 +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_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)
+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 (mknod, frame, cookie, op_ret, op_errno, inode,
-                 buf, preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(mkdir, 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,
+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 (mkdir, 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_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)
+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 (unlink, frame, cookie, op_ret, op_errno, preparent,
-                 postparent, xdata);
-        return 0;
+    FOP_CBK(rmdir, frame, cookie, op_ret, op_errno, 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,
-                   dict_t *xdata)
+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 (rmdir, 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_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_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 (symlink, frame, cookie, op_ret, op_errno, inode, buf,
-                 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_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_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 (rename, frame, cookie, op_ret, op_errno, buf, preoldparent,
-                 postoldparent, prenewparent, postnewparent, xdata);
-        return 0;
+    FOP_CBK(link, frame, cookie, op_ret, op_errno, 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_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 (link, frame, cookie, op_ret, op_errno, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(create, frame, cookie, op_ret, op_errno, fd, inode, buf, preparent,
+            postparent, 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_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 (create, frame, cookie, op_ret, op_errno, fd, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(open, frame, cookie, op_ret, op_errno, fd, 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,
+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 (open, frame, cookie, op_ret, op_errno, fd, xdata);
-        return 0;
+    FOP_CBK(readv, frame, cookie, op_ret, op_errno, vector, count, stbuf,
+            iobref, 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_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 (readv, frame, cookie, op_ret, op_errno, vector, count,
-                 stbuf, iobref, xdata);
-        return 0;
+    FOP_CBK(writev, frame, cookie, op_ret, op_errno, prebuf, postbuf, 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_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 (writev, frame, cookie, op_ret, op_errno, prebuf, postbuf,
-                 xdata);
-        return 0;
+    FOP_CBK(put, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-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)
+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 (put, frame, cookie, op_ret, op_errno, inode, buf, preparent,
-                 postparent, 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
@@ -557,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
@@ -566,752 +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_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)
+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)
 {
-        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);
+    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_readv (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)
+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, readv, fd, size,
-                    offset, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    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)
+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_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, locked_on, numsubvols, replies, output, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK,
-                    NULL);
+    FOP_ONLIST(subvols, locked_on, numsubvols, replies, output, frame, entrylk,
+               dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, 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_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)
+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);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                    NULL);
+    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);
 
-        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_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;
         }
+    }
 
-        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_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;
-                }
-
-                /* 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);
-                        }
-                        break;
-                }
+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_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+        /* 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);
 }
 
 int
-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 {
-                                memset (locked_on, 0, numsubvols);
-                        }
-                        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 9127dde6dfb..00000000000
--- a/libglusterfs/src/cluster-syncop.h
+++ /dev/null
@@ -1,227 +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);
-
-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/common-utils.c b/libglusterfs/src/common-utils.c
index 374b76b0410..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,25 +34,26 @@
 #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 "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
@@ -63,138 +63,338 @@
 #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
-gf_xxh64_wrapper(const unsigned char *data, size_t const len, unsigned long long const seed,
-                 char *xxh64)
+gf_xxh64_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;
+    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);
+    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]);
+    for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
+        snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]);
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+
+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;
 }
 
 /**
@@ -206,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;
 }
 
 /**
@@ -231,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;
 
-        cache = *dnscache;
-        if (cache->first && !cache->next) {
-                freeaddrinfo(cache->first);
-                cache->first = cache->next = NULL;
-                gf_msg_trace ("resolver", 0, "flushing DNS cache");
+        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);
 
-        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;
+            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_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) {
+        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,
+                     "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;
         }
 
-        return 0;
+        gf_msg_debug("resolver", 0,
+                     "next DNS query will return: "
+                     "ip-%s port-%s",
+                     host, service);
+    }
+
+    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;
 }
 
 /**
@@ -380,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);
 }
 
 /**
@@ -396,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;
 }
 
 /**
@@ -409,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);
 }
 
 /**
@@ -425,1532 +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;
-        }
+    register char *s, *t;
 
-        for (s = string; isspace (*s); s++)
-                ;
-
-        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++;
-        }
+    t = s + strlen(s) - 1;
+    while (t > s && isspace(*t))
+        t--;
+    *++t = '\0';
 
-        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]);
-
-        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;
+    long long l = 0LL;
+    int rv = 0;
 
-        rv = _gf_string2longlong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2longlong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        *n = (int64_t) l;
-        return 0;
+    *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 (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 (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;
 }
 
 /**
@@ -1963,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;
 }
 
 /**
@@ -1994,167 +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)++;
 }
 
 void
-gf_strTrim (char **s)
+gf_strTrim(char **s)
 {
-        char *end = NULL;
+    char *end = NULL;
 
-        end = *s + strlen(*s) - 1;
-        while (end > *s && isspace ((unsigned char)*end))
-                end--;
+    end = *s + strlen(*s) - 1;
+    while (end > *s && isspace((unsigned char)*end))
+        end--;
 
-        *(end+1) = '\0';
+    *(end + 1) = '\0';
 
-        while (isspace (**s))
-                (*s)++;
+    while (isspace(**s))
+        (*s)++;
 
-        return;
+    return;
 }
 
 char *
-nwstrtail (char *str, char *pattern)
+nwstrtail(char *str, char *pattern)
 {
-        for (;;) {
-                skipwhite (&str);
-                skipwhite (&pattern);
+    for (;;) {
+        skipwhite(&str);
+        skipwhite(&pattern);
 
-                if (*str != *pattern || !*str)
-                        break;
+        if (*str != *pattern || !*str)
+            break;
 
-                str++;
-                pattern++;
-        }
+        str++;
+        pattern++;
+    }
 
-        return *pattern ? NULL : str;
-}
-
-void
-skipword (char **s)
-{
-        if (!*s)
-                return;
-
-        skipwhite (s);
-
-        while (!isspace(**s))
-                (*s)++;
-}
-
-char *
-get_nth_word (const char *str, int n)
-{
-        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 (i = 0; i < n-1; i++)
-                skipword (&start);
-
-        skipwhite (&start);
-        end = strpbrk ((const char *)start, " \t\n\0");
-
-        if (!end)
-                goto out;
-
-        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;
 }
 
 /**
@@ -2171,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;
 }
 
 /**
@@ -2196,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 != 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++)
+        ;
+    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;
 
-        return is_last;
+    return is_last;
 }
 
 /*
@@ -2232,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)
@@ -2270,142 +2396,167 @@ 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] != '*')) {
+        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 (dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) {
+        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
-         * delimiters.
-         */
-        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;
 }
 
 /**
@@ -2419,152 +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;
-
-        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;
+    char *slash = NULL;
+    char *paddr = NULL;
+    char *endptr = NULL;
+    long prefixlen = -1;
+    gf_boolean_t 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;
-        }
+    if (address == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return _gf_false;
+    }
 
-        *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;
-        }
+    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;
 }
 
 /**
@@ -2574,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;
 }
 
 /**
@@ -2634,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;
 }
 
 /*
@@ -2683,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
@@ -2755,108 +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;
-
-        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';
+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;
+    return buf;
 }
 
 char *
-gf_leaseid_get ()
+gf_leaseid_get()
 {
-        return glusterfs_leaseid_buf_get ();
+    return glusterfs_leaseid_buf_get();
 }
 
 char *
-gf_existing_leaseid ()
+gf_existing_leaseid()
 {
-        return glusterfs_leaseid_exist ();
+    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
@@ -2864,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;
 }
 
 /*
@@ -2888,381 +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;
-}
-
-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;
+    return result;
 }
 
 int
-validate_brick_name (char *brick)
+validate_brick_name(char *brick)
 {
-        char *delimiter = NULL;
-        int  ret = 0;
-        delimiter = strrchr (brick, ':');
-        if (!delimiter || delimiter == brick
-            || *(delimiter+1) != '/')
-                ret = -1;
+    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);
+
+    memsize = page_size * num_pages;
+#endif
+
+#if defined GF_DARWIN_HOST_OS || defined __FreeBSD__
 
-	page_size = sysconf (_SC_PAGESIZE);
-	num_pages = sysconf (_SC_PHYS_PAGES);
+    size_t len = sizeof(memsize);
+    int name[] = {CTL_HW, HW_PHYSMEM};
 
-	memsize = page_size * num_pages;
+    sysctl(name, 2, &memsize, &len, NULL, 0);
 #endif
 
-#if defined GF_BSD_HOST_OS || defined GF_DARWIN_HOST_OS
+#if defined __NetBSD__
 
-	size_t len = sizeof(memsize);
-	int name [] = { CTL_HW, HW_PHYSMEM };
+    size_t len = sizeof(memsize);
+    int name64[] = {CTL_HW, HW_PHYSMEM64};
 
-	sysctl (name, 2, &memsize, &len, NULL, 0);
+    sysctl(name64, 2, &memsize, &len, NULL, 0);
+    if (memsize == -1)
+        sysctl(name64, 2, &memsize, &len, NULL, 0);
 #endif
-	return memsize;
+    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);
-
-        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) {
-                        path[path_len] = '/';
-                }
+    /* Strip the extra slashes and return */
+    bzero(path, strlen(path));
+    path[0] = '/';
+    dir = strtok_r(tmppath, "/", &tmpstr);
+
+    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 (const char ***fmts, const char ***zeros)
+_gf_timestuff(const char ***fmts, const char ***zeros)
 {
-        *fmts = __gf_timefmts;
-        *zeros = __gf_zerotimes;
+    *fmts = __gf_timefmts;
+    *zeros = __gf_zerotimes;
 }
 
-
 char *
-generate_glusterfs_ctx_id (void)
+generate_glusterfs_ctx_id(void)
 {
-        uuid_t         ctxid;
-        char          *tmp = NULL;
+    uuid_t ctxid;
+    char *tmp = NULL;
 
-        gf_uuid_generate (ctxid);
-        tmp = uuid_utoa (ctxid);
+    gf_uuid_generate(ctxid);
+    tmp = uuid_utoa(ctxid);
 
-        return gf_strdup (tmp);
+    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
@@ -3270,328 +3408,323 @@ 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;
-        }
-
-        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;
-        }
-
-        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;
-                }
-        }
+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;
+        }
+    }
 
 out:
-        if (addr1) {
-                freeaddrinfo(addr1);
-        }
-        if (addr2) {
-                freeaddrinfo(addr2);
-        }
-        return ret;
-
+    if (addr1) {
+        freeaddrinfo(addr1);
+    }
+    if (addr2) {
+        freeaddrinfo(addr2);
+    }
+    return ret;
 }
 
 /*
@@ -3599,509 +3732,566 @@ out:
  * 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);
+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 = EINVAL;
-                goto out;
+            errno = 0;
+            ret = 0;
+            break;
         }
+    }
 
-        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 (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 (tmp) {
-                GF_FREE (tmp);
+    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_volfile_server_common (cmd_args_t *cmd_args, const char *host,
-                              const char *transport, int port)
+gf_set_log_file_path(cmd_args_t *cmd_args, glusterfs_ctx_t *ctx)
 {
-        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;
-        }
+    int i = 0;
+    int j = 0;
+    int ret = 0;
+    int tmp_len = 0;
+    char tmp_str[1024] = {
+        0,
+    };
 
-        INIT_LIST_HEAD (&server->list);
+    if (!cmd_args)
+        goto done;
 
-        server->volfile_server = gf_strdup (host);
-        if (!server->volfile_server) {
-                errno = ENOMEM;
-                goto out;
+    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] = '-';
         }
 
-        server->transport = gf_strdup (transport);
-        if (!server->transport) {
-                errno = ENOMEM;
-                goto out;
-        }
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str);
+        if (ret > 0)
+            ret = 0;
+        goto done;
+    }
 
-        server->port = port;
+    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) {
-                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;
-        }
+        goto done;
+    }
 
-        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;
-                }
+    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;
+}
 
-        list_add_tail (&server->list, &cmd_args->volfile_servers);
+int
+gf_set_log_ident(cmd_args_t *cmd_args)
+{
+    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;
-out:
-        if (-1 == ret) {
-                if (server) {
-                        GF_FREE (server->volfile_server);
-                        GF_FREE (server->transport);
-                        GF_FREE (server);
-                }
+    else
+        return ret;
+
+    /* remove .log suffix */
+    if (NULL != (ptr = strrchr(cmd_args->log_ident, '.'))) {
+        if (strcmp(ptr, ".log") == 0) {
+            ptr[0] = '\0';
         }
+    }
 
-        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;
-        int   tmp_len = 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_thread_cleanup_xint(pthread_t thread)
+{
+    int ret = 0;
+    void *res = NULL;
 
-        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;
+    ret = pthread_cancel(thread);
+    if (ret != 0)
+        goto error_return;
 
-                goto done;
-        }
+    ret = pthread_join(thread, &res);
+    if (ret != 0)
+        goto error_return;
 
-        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 (res != PTHREAD_CANCELED)
+        goto error_return;
 
-        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;
+    ret = 0;
+
+error_return:
+    return ret;
 }
 
-int
-gf_set_log_ident (cmd_args_t *cmd_args)
+void
+gf_thread_set_vname(pthread_t thread, const char *name, va_list args)
 {
-        int              ret = 0;
-        char            *ptr = NULL;
+    char thread_name[GF_THREAD_NAME_LIMIT];
+    int ret;
 
-        if (cmd_args->log_file == NULL) {
-                /* no ident source */
-                return 0;
-        }
+    /* Initialize the thread name with the prefix (not NULL terminated). */
+    memcpy(thread_name, GF_THREAD_NAME_PREFIX,
+           sizeof(GF_THREAD_NAME_PREFIX) - 1);
 
-        /* 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);
-        }
+    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;
+    }
 
-        if (ret > 0)
-                ret = 0;
-        else
-                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);
+    }
 
-        /* remove .log suffix */
-        if (NULL != (ptr = strrchr (cmd_args->log_ident, '.'))) {
-                if (strcmp (ptr, ".log") == 0) {
-                        ptr[0] = '\0';
-                }
-        }
+#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);
+    }
+}
 
-        return ret;
+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_cleanup_xint (pthread_t thread)
+gf_thread_vcreate(pthread_t *thread, const pthread_attr_t *attr,
+                  void *(*start_routine)(void *), void *arg, const char *name,
+                  va_list args)
 {
-        int ret = 0;
-        void *res = NULL;
+    sigset_t set, old;
+    int ret;
 
-        ret = pthread_cancel (thread);
-        if (ret != 0)
-                goto error_return;
+    sigemptyset(&old);
+    sigfillset(&set);
+    sigdelset(&set, SIGSEGV);
+    sigdelset(&set, SIGBUS);
+    sigdelset(&set, SIGILL);
+    sigdelset(&set, SIGSYS);
+    sigdelset(&set, SIGFPE);
+    sigdelset(&set, SIGABRT);
 
-        ret = pthread_join (thread, &res);
-        if (ret != 0)
-                goto error_return;
+    pthread_sigmask(SIG_BLOCK, &set, &old);
 
-        if (res != PTHREAD_CANCELED)
-                goto error_return;
+    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);
+    }
 
-        ret = 0;
+    pthread_sigmask(SIG_SETMASK, &old, NULL);
 
- error_return:
-        return ret;
+    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.
-         */
-
-        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);
-                #elif defined(__FreeBSD__)
-                        pthread_set_name_np(*thread, thread_name);
-                #else
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_PTHREAD_NAMING_FAILED,
-                                "Could not set thread name: %s",
-                                thread_name);
-                #endif
-        }
+gf_thread_create(pthread_t *thread, const pthread_attr_t *attr,
+                 void *(*start_routine)(void *), void *arg, const char *name,
+                 ...)
+{
+    va_list args;
+    int ret;
 
-        pthread_sigmask (SIG_SETMASK, &old, NULL);
+    va_start(args, name);
+    ret = gf_thread_vcreate(thread, attr, start_routine, arg, name, args);
+    va_end(args);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_thread_create_detached (pthread_t *thread,
-                         void *(*start_routine)(void *), void *arg,
-                         const char *name)
+gf_thread_create_detached(pthread_t *thread, void *(*start_routine)(void *),
+                          void *arg, const char *name, ...)
 {
-        pthread_attr_t attr;
-        int ret = -1;
+    pthread_attr_t attr;
+    va_list args;
+    int ret = -1;
 
-        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;
-        }
+    ret = pthread_attr_init(&attr);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_ATTR_INIT_FAILED,
+                NULL);
+        return -1;
+    }
 
-        pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
-        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;
-        }
+    va_start(args, name);
+    ret = gf_thread_vcreate(thread, &attr, start_routine, arg, name, args);
+    va_end(args);
 
-        pthread_attr_destroy (&attr);
+    pthread_attr_destroy(&attr);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_skip_header_section (int fd, int header_len)
+gf_skip_header_section(int fd, int header_len)
 {
-        int  ret           = -1;
+    int ret = -1;
 
-        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;
-        }
+    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;
+    return ret;
 }
 
 /* Below function is use to check at runtime if pid is running */
 
 gf_boolean_t
-gf_is_pid_running (int pid)
+gf_is_pid_running(int pid)
 {
-        char fname[32] = {0,};
+#ifdef __FreeBSD__
+    int ret = -1;
 
-        snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid);
+    ret = sys_kill(pid, 0);
+    if (ret < 0) {
+        return _gf_false;
+    }
+#else
+    char fname[32] = {
+        0,
+    };
+    int fd = -1;
 
-        if (sys_access (fname , R_OK) != 0) {
-                return _gf_false;
-        }
+    snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid);
 
-        return _gf_true;
+    fd = sys_open(fname, O_RDONLY, 0);
+    if (fd < 0) {
+        return _gf_false;
+    }
 
+    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_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to read pidfile: %s", pidfile);
-                *pid = -1;
-        }
-
-        running = gf_is_pid_running (*pid);
+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
@@ -4111,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;
 }
 
 /*
@@ -4143,155 +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[]                  = "/tmp/glfs-bt-XXXXXX";
-
-        frames = backtrace (array, GF_BACKTRACE_FRAME_COUNT);
-        if (!frames)
-                return -1;
-
-        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
-        fd = mkstemp (tmpl);
-        if (fd == -1)
-                return -1;
-
-        /* 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_msg (THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_OP_FAILED,
-                        "Unable to delete temporary file: %s", tmpl);
-        }
-
-        /*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);
+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;
 
-        fp = fdopen (fd, "r");
-        if (!fp) {
-                sys_close (fd);
-                ret = -1;
-                goto out;
-        }
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    fd = mkstemp(tmpl);
+    if (fd == -1)
+        return -1;
 
-        ret = fseek (fp, 0L, SEEK_SET);
-        if (ret)
-                goto out;
-
-        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);
-
-        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
@@ -4302,72 +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;
+    char *bt = NULL;
 
-        if (!buf) {
-                bt = THIS->ctx->btbuf;
-                GF_ASSERT (bt);
-
-        } 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;
-        }
-
-        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;
+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_SEEK) {
-                if (op_errno == ENXIO) {
-                        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
+    }
 
-        return GF_LOG_ERROR;
+    return GF_LOG_ERROR;
 }
 
 /* This function will build absolute path of file/directory from the
@@ -4385,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;
-                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;
+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;
-        }
+            }
 
-        /* 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
@@ -4505,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_SKIP_IRRELEVANT_ENTRIES (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_SKIP_IRRELEVANT_ENTRIES (entry, dir, scratch);
-        }
-
-        ret = sys_closedir (dir);
-        if (ret) {
-                gf_msg_debug (this->name, 0, "Failed to close dir %s. Reason :"
-                              " %s", delete_path, strerror (errno));
-        }
+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_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
@@ -4575,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:
@@ -4780,7 +4993,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_SETACTIVELK:
         case GF_FOP_ICREATE:
         case GF_FOP_NAMELINK:
-                return "HIGH";
+            return "HIGH";
 
         case GF_FOP_CREATE:
         case GF_FOP_FLUSH:
@@ -4806,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:
@@ -4820,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:
@@ -4829,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;
 }
 
 /**
@@ -5029,105 +5239,73 @@ close_fds_except (int *fdv, size_t count)
  *         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);
+    if (!*groups)
+        return -1;
 
-        /*
-         * 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;
+    /*
+     * 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;
-}
+glusterfs_compute_sha256(const unsigned char *content, size_t size,
+                         char *sha256_hash)
+{
+    SHA256_CTX sha256;
 
-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;
-        }
+    SHA256_Init(&sha256);
+    SHA256_Update(&sha256, (const unsigned char *)(content), size);
+    SHA256_Final((unsigned char *)sha256_hash, &sha256);
 
-out:
-        return NULL;
+    return 0;
 }
 
 /* * Safe wrapper function for strncpy.
@@ -5137,73 +5315,151 @@ out:
  */
 
 char *
-gf_strncpy (char *dest, const char *src, const size_t dest_size)
+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;
+    strncpy(dest, src, dest_size - 1);
+    dest[dest_size - 1] = '\0';
+    return dest;
 }
 
 int
-gf_replace_old_iatt_in_dict (dict_t *xdata)
+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 */
-        int32_t len = sizeof(struct old_iatt);
+    int ret;
+    struct old_iatt *o_iatt; /* old iatt structure */
+    struct iatt *c_iatt;     /* current iatt */
 
-        if (!xdata) {
-                return 0;
-        }
+    if (!xdata) {
+        return 0;
+    }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **)&c_iatt);
-        if (ret < 0) {
-                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, len, gf_common_mt_char);
-        if (!o_iatt) {
-                return -1;
-        }
+    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);
+    oldiatt_from_iatt(o_iatt, c_iatt);
 
-        ret = dict_set_bin (xdata, DHT_IATT_IN_XDATA_KEY, o_iatt, len);
-        if (ret) {
-                GF_FREE (o_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;
+    return ret;
 }
 
 int
-gf_replace_new_iatt_in_dict (dict_t *xdata)
+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 */
-        int32_t len = sizeof(struct iatt);
+    int ret;
+    struct old_iatt *o_iatt; /* old iatt structure */
+    struct iatt *c_iatt;     /* new iatt */
 
-        if (!xdata) {
-                return 0;
-        }
+    if (!xdata) {
+        return 0;
+    }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **)&o_iatt);
-        if (ret < 0) {
-                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, len, gf_common_mt_char);
-        if (!c_iatt) {
-                return -1;
-        }
+    c_iatt = GF_CALLOC(1, sizeof(struct iatt), gf_common_mt_char);
+    if (!c_iatt) {
+        return -1;
+    }
 
-        iatt_from_oldiatt (c_iatt, o_iatt);
+    iatt_from_oldiatt(c_iatt, o_iatt);
 
-        ret = dict_set_bin (xdata, DHT_IATT_IN_XDATA_KEY, c_iatt, len);
-        if (ret) {
-                GF_FREE (c_iatt);
-        }
+    ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, c_iatt,
+                       sizeof(struct iatt));
+    if (ret) {
+        GF_FREE(c_iatt);
+    }
 
-        return ret;
+    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:
+            return DT_UNKNOWN;
+    }
+}
+
+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 55ef916ddf7..00000000000
--- a/libglusterfs/src/common-utils.h
+++ /dev/null
@@ -1,979 +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"
-#include "iobuf.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!=0)?(b):1))*(b))
-#define 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 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"
-#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_NAMEMAX 11
-#define GF_THREAD_NAME_PREFIX "glfs_"
-#define GF_THREAD_NAME_PREFIX_LEN 5
-
-#include <stdbool.h>
-#define gf_boolean_t    bool
-#define _gf_false       false
-#define _gf_true        true
-
-/*
- * 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_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);
-
-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)
-
-
-#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_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)
-
-#define GF_SKIP_IRRELEVANT_ENTRIES(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 (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 (&fmts, &zeros);
-                timefmt_last = gf_timefmt_last;
-        }
-        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);
-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 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 gf_xxh64_wrapper(const unsigned char *data, size_t const len,
-                      unsigned long long const 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);
-
-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 *);
-
-#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 a27fe20ce64..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,521 +15,530 @@
 #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);
-        } 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 {
-                        ret = read (attrfd, value, size);
-                }
-                close (attrfd);
+    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 {
-                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;
+            ret = read(attrfd, value, size);
         }
-        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;
+    char *mapped_path = NULL;
+    int ret = -1;
 
-        ret = solaris_xattr_resolve_path (new_path, &mapped_path);
+    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);
+    }
 
-        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);
-
+    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 */
@@ -539,27 +547,27 @@ out:
 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);
-        }
+    /*
+     * 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 */
 
@@ -567,44 +575,44 @@ gf_extattr_list_reshape(char *bsd_list, ssize_t size)
 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 afd12cd22f8..3d890b04ec9 100644
--- a/libglusterfs/src/ctx.c
+++ b/libglusterfs/src/ctx.c
@@ -10,87 +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;
+
+    /* 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;
+    }
 
-        ctx->mem_acct_enable = gf_global_mem_acct_enable_get();
+    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);
+    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;
-                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);
+    /* 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);
 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 2bc1ec28649..a0ba1cfb299 100644
--- a/libglusterfs/src/default-args.c
+++ b/libglusterfs/src/default-args.c
@@ -13,1660 +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_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)
+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)
 {
-        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;
+    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_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_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 (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);
+    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)
+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;
+    if (fd)
+        args->fd = fd_ref(fd);
+    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_flush_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_fsync_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                  dict_t *xdata)
+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;
+    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);
-
-        return 0;
-}
-
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-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;
+    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, SHA256_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);
+    }
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+
+    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);
 }
 
 int
-args_icreate_store (default_args_t *args,
-                    loc_t *loc, mode_t mode, dict_t *xdata)
+args_icreate_store(default_args_t *args, loc_t *loc, mode_t mode, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode = mode;
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_namelink_store (default_args_t *args,
-                     loc_t *loc, dict_t *xdata)
+args_namelink_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
+}
+
+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 (xdata)
+        args->xdata = dict_ref(xdata);
+
+    return 0;
+}
+
+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);
+
+    return 0;
 }
 
 void
-args_cbk_wipe (default_args_cbk_t *args_cbk)
+args_cbk_wipe(default_args_cbk_t *args_cbk)
 {
-        if (!args_cbk)
-                return;
-        if (args_cbk->inode)
-                inode_unref (args_cbk->inode);
+    if (!args_cbk)
+        return;
+    if (args_cbk->inode)
+        inode_unref(args_cbk->inode);
 
-        GF_FREE ((char *)args_cbk->buf);
+    GF_FREE((char *)args_cbk->buf);
 
-        GF_FREE (args_cbk->vector);
+    GF_FREE(args_cbk->vector);
 
-        if (args_cbk->iobref)
-                iobref_unref (args_cbk->iobref);
+    if (args_cbk->iobref)
+        iobref_unref(args_cbk->iobref);
 
-        if (args_cbk->fd)
-                fd_unref (args_cbk->fd);
+    if (args_cbk->fd)
+        fd_unref(args_cbk->fd);
 
-        if (args_cbk->xattr)
-                dict_unref (args_cbk->xattr);
+    if (args_cbk->xattr)
+        dict_unref(args_cbk->xattr);
 
-        GF_FREE (args_cbk->strong_checksum);
+    GF_FREE(args_cbk->strong_checksum);
 
-        if (args_cbk->xdata)
-                dict_unref (args_cbk->xdata);
+    if (args_cbk->xdata)
+        dict_unref(args_cbk->xdata);
 
-        if (!list_empty (&args_cbk->entries.list))
-                gf_dirent_free (&args_cbk->entries);
+    if (!list_empty(&args_cbk->entries.list))
+        gf_dirent_free(&args_cbk->entries);
 }
 
 void
-args_wipe (default_args_t *args)
+args_wipe(default_args_t *args)
 {
-        if (!args)
-                return;
-
-        loc_wipe (&args->loc);
+    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 7d46fefa663..00000000000
--- a/libglusterfs/src/default-args.h
+++ /dev/null
@@ -1,501 +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_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);
-
-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);
-
-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 74550030446..3cf707f42aa 100644
--- a/libglusterfs/src/defaults-tmpl.c
+++ b/libglusterfs/src/defaults-tmpl.c
@@ -25,212 +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,
-        .put = default_put,
-        .icreate = default_icreate,
-        .namelink = default_namelink,
+    .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, ...)
 {
-        GF_UNUSED int ret = 0;
-        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;
-                }
-        }
-        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;
+        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_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)
+default_fini(xlator_t *this)
 {
-        if (this && this->private)
-                GF_FREE (this->private);
+    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 5e56cc2c9f9..00000000000
--- a/libglusterfs/src/defaults.h
+++ /dev/null
@@ -1,1361 +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);
-
-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);
-
-/* 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);
-
-/* _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);
-
-/* _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_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_mem_acct_init (xlator_t *this);
-
-void
-default_fini (xlator_t *this);
-
-#endif /* _DEFAULTS_H */
diff --git a/libglusterfs/src/dict.c b/libglusterfs/src/dict.c
index 646680fb889..1d9be9217a6 100644
--- a/libglusterfs/src/dict.c
+++ b/libglusterfs/src/dict.c
@@ -16,226 +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-fops.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);
 };
 
-#define VALIDATE_DATA_AND_LOG(data, type, key, ret_val) do {                 \
-                if (!data || !data->data) {                             \
-                        gf_msg_callingfn ("dict", GF_LOG_WARNING, 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_INFO, 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)
+#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)
 
-data_t *
-get_new_data ()
+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;
-        }
+    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;
-                }
+    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);
-
-        return dict;
-}
+    dict->free_pair.key = NULL;
+    dict->totkvlen = 0;
+    LOCK_INIT(&dict->lock);
 
-dict_t *
-get_new_dict (void)
-{
-        return get_new_dict_full (1);
+    return dict;
 }
 
 dict_t *
-dict_new (void)
+dict_new(void)
 {
-        dict_t *dict = NULL;
+    dict_t *dict = get_new_dict_full(1);
 
-        dict = get_new_dict_full(1);
+    if (dict)
+        dict_ref(dict);
 
-        if (dict)
-                dict_ref (dict);
-
-        return dict;
+    return dict;
 }
 
 int32_t
-is_data_equal (data_t *one,
-               data_t *two)
+is_data_equal(data_t *one, data_t *two)
 {
-        struct iatt *iatt1, *iatt2;
+    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;
-	}
+    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 == two)
-                return 1;
+    if (one == two)
+        return 1;
 
-        if (one->data == two->data)
-                return 1;
+    if (one->data == two->data)
+        return 1;
 
-        if (one->data_type != two->data_type) {
-                return 0;
+    if (one->data_type != two->data_type) {
+        return 0;
+    }
+
+    if (one->data_type == GF_DATA_TYPE_IATT) {
+        if ((one->len < sizeof(struct iatt)) ||
+            (two->len < sizeof(struct iatt))) {
+            return 0;
         }
 
-        if (one->data_type == GF_DATA_TYPE_IATT) {
-                if ((one->len < sizeof(struct iatt)) ||
-                    (two->len < sizeof(struct iatt))) {
-                        return 0;
-                }
+        iatt1 = (struct iatt *)one->data;
+        iatt2 = (struct iatt *)two->data;
 
-                iatt1 = (struct iatt *)one->data;
-                iatt2 = (struct iatt *)two->data;
+        /* 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;
+        }
 
-                /* 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;
+        /* 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 (gf_uuid_compare(iatt1->ia_gfid, iatt2->ia_gfid) != 0) {
-                        return 0;
-                }
-
-                /* 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;
+                        if (iatt1->ia_type == IA_IFREG) {
+                                if (iatt1->ia_size != iatt2->ia_size) {
+                                        return 0;
+                                }
                         }
-                }
-*/
-                return 1;
-        }
-
-        if (one->len != two->len)
-                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;
+    struct dict_cmp *cmp = data;
+    dict_t *two = cmp->dict;
+    data_t *value2 = dict_get(two, key1);
 
-        two = cmp->dict;
-        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
@@ -246,1073 +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))
+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};
+    int num_matches1 = 0;
+    int num_matches2 = 0;
+    struct dict_cmp cmp = {0};
 
-        if (one == two)
-                return _gf_true;
+    if (one == two)
+        return _gf_true;
 
-        if (!match)
-                match = dict_match_everything;
+    if (!match)
+        match = dict_match_everything;
 
-        if ((one == NULL) || (two == NULL)) {
-                num_matches1 = dict_foreach_match(one ? one : two, match, NULL,
-                                                  dict_null_foreach_fn, NULL);
-                goto done;
-        }
+    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);
+    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 == -1)
+        return _gf_false;
 
-        if ((num_matches1 == one->count) && (one->count == two->count))
-                return _gf_true;
+    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);
+    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;
+    /* 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->is_static)
-                        GF_FREE (data->data);
+    if (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->data_type = old->data_type;
-        }
+    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);
+
+            if (pair->prev)
+                pair->prev->next = pair->next;
+            else
+                this->members_list = pair->next;
 
-                prev = pair;
-                pair = pair->hash_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;
-        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);
-                }
-                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)
 {
-        uint64_t ref = 0;
+    uint64_t ref = 0;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return;
+    }
 
-        ref = GF_ATOMIC_DEC (this->refcount);
+    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;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (this->refcount);
-        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, "data is NULL");
-                return;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "data is NULL");
+        return;
+    }
 
-        ref = GF_ATOMIC_DEC (this->refcount);
+    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, "data is NULL");
-                return NULL;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "data is NULL");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (this->refcount);
+    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->data_type = GF_DATA_TYPE_INT;
+    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;
-        data->data_type = GF_DATA_TYPE_INT;
+    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->data_type = GF_DATA_TYPE_INT;
+    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->data_type = GF_DATA_TYPE_INT;
+    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->data_type = GF_DATA_TYPE_INT;
+    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->data_type = GF_DATA_TYPE_UINT;
+    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_t *data = get_new_data();
 
-        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->data_type = GF_DATA_TYPE_DOUBLE;
+    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->data_type = GF_DATA_TYPE_UINT;
+    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->data_type = GF_DATA_TYPE_UINT;
+    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;
 
-        data->data_type = GF_DATA_TYPE_PTR;
-        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;
-        data->data_type = GF_DATA_TYPE_STR;
+    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();
 
-        return data;
+    if (!data) {
+        return NULL;
+    }
+    data->len = vallen + 1;
+    data->data_type = GF_DATA_TYPE_STR;
+
+    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;
-        data->data_type = GF_DATA_TYPE_STR;
+    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->data_type = GF_DATA_TYPE_PTR;
+    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_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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
-
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    char *endptr = NULL;
+    int64_t value = 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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
-
-        int16_t value = 0;
-        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;
-        }
+    char *endptr = NULL;
+    int64_t value = 0;
 
-        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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
-
-        int8_t value = 0;
-        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 > 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;
-        }
+    char *endptr = NULL;
+    int64_t value = 0;
 
-        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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -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';
+    errno = 0;
+    value = strtoull(data->data, &endptr, 0);
 
-        return strtoll (str, NULL, 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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    char *endptr = NULL;
+    uint64_t value = 0;
 
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
-
-	uint16_t value = 0;
-        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';
-
-	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;
-	}
-
-        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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
-
-	uint32_t value = 0;
-        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;
+    uint64_t value = 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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, "null", 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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", 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)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", 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_msg("glusterfs", GF_LOG_ERROR, ENOBUFS,
-                       LG_MSG_UNDERSIZED_BUF,
-                       "data value for '%s' is smaller than expected", key);
-                return NULL;
-        }
+data_to_iatt(data_t *data, char *key)
+{
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, NULL);
 
-        return (struct iatt *)data->data;
+    /* 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:
@@ -1321,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,
@@ -1372,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.
  *
@@ -1397,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;
 }
 
 /*
@@ -1493,606 +1495,569 @@ 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;
+    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_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;
-        }
+    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 = 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;
-        }
+    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 = 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;
-
-        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 = 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;
-
-        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 = 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;
-        }
-
-        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 = 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;
+    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 = 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);
+    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);
+    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);
+    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;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int64_ptr (data, val);
+    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);
+    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;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
 
-        ret = data_to_uint32_ptr (data, val);
+    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);
+    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;
 }
 
 /*
@@ -2105,23 +2070,23 @@ err:
  * <0: Error
  */
 int
-dict_check_flag (dict_t *this, char *key, int flag)
+dict_check_flag(dict_t *this, char *key, int flag)
 {
-        data_t  *data = NULL;
-        int     ret = -ENOENT;
+    data_t *data = NULL;
+    int ret = -ENOENT;
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                return ret;
-        }
+    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;
+    if (BIT_VALUE((unsigned char *)(data->data), flag))
+        ret = 1;
+    else
+        ret = 0;
 
-        data_unref(data);
-        return ret;
+    data_unref(data);
+    return ret;
 }
 
 /*
@@ -2130,139 +2095,126 @@ dict_check_flag (dict_t *this, char *key, int flag)
  * 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;
-        uint32_t        hash            = 0;
-        data_pair_t     *pair           = NULL;
-        char            *ptr            = NULL;
-        int             hashval         = 0;
-
-        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;
-        }
+_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);
 
-        /*
-         * 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 = SuperFastHash (key, strlen (key));
-        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);
-                        ret = 0;
-                } else {
-                        ptr = GF_CALLOC(1, DICT_MAX_FLAGS / 8,
-                                        gf_common_mt_char);
-                        if (!ptr) {
-                                gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                       LG_MSG_NO_MEMORY,
-                                       "unable to allocate flag bit array");
-                                ret = -ENOMEM;
-                                goto err;
-                        }
-
-                        data = data_from_dynptr(ptr, DICT_MAX_FLAGS / 8);
-
-                        if (!data) {
-                                gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                       LG_MSG_NO_MEMORY,
-                                       "unable to allocate data");
-                                GF_FREE(ptr);
-                                ret = -ENOMEM;
-                                goto err;
-                        }
+        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;
+            }
 
-                        if (op == DICT_FLAG_SET)
-                                BIT_SET((unsigned char *)(data->data), flag);
-                        else
-                                BIT_CLEAR((unsigned char *)(data->data), flag);
-
-                        if (this->free_pair_in_use) {
-                                pair = mem_get0 (THIS->ctx->dict_pair_pool);
-                                if (!pair) {
-                                        gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                               LG_MSG_NO_MEMORY,
-                                               "unable to allocate dict pair");
-                                        ret = -ENOMEM;
-                                        goto err;
-                                }
-                        } else {
-                                pair = &this->free_pair;
-                                this->free_pair_in_use = _gf_true;
-                        }
+            data = data_from_dynptr(ptr, DICT_MAX_FLAGS / 8);
 
-                        pair->key = (char *)GF_CALLOC(1, strlen (key) + 1,
-                                                      gf_common_mt_char);
-                        if (!pair->key) {
-                                gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                       LG_MSG_NO_MEMORY,
-                                       "unable to allocate dict pair");
-                                ret = -ENOMEM;
-                                goto err;
-                        }
-                        strcpy (pair->key, key);
-                        pair->key_hash = hash;
-                        pair->value = data_ref (data);
+            if (!data) {
+                gf_smsg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, "data",
+                        NULL);
+                GF_FREE(ptr);
+                ret = -ENOMEM;
+                goto err;
+            }
 
-                        hashval = hash % this->hash_size;
-                        pair->hash_next = this->members[hashval];
-                        this->members[hashval] = pair;
+            if (op == DICT_FLAG_SET)
+                BIT_SET((unsigned char *)(data->data), flag);
+            else
+                BIT_CLEAR((unsigned char *)(data->data), flag);
 
-                        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->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;
-                }
+            if (this->max_count < this->count)
+                this->max_count = this->count;
         }
+    }
 
-        UNLOCK (&this->lock);
-        return 0;
+    UNLOCK(&this->lock);
+    return 0;
 
 err:
-        if (key && this)
-                UNLOCK (&this->lock);
-
-        if (pair) {
-                if (pair->key)
-                        free(pair->key);
+    if (key && this)
+        UNLOCK(&this->lock);
 
-                if (pair == &this->free_pair) {
-                        this->free_pair_in_use = _gf_false;
-                } else {
-                        mem_put (pair);
-                }
+    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);
-
+    if (data)
+        data_destroy(data);
 
-        gf_msg("dict", GF_LOG_ERROR, EINVAL,
-               LG_MSG_DICT_SET_FAILED,
-               "unable to set key (%s) in dict ", key);
+    gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_DICT_SET_FAILED, "key=%s", key,
+            NULL);
 
-        return ret;
+    return ret;
 }
 
 /*
@@ -2275,342 +2227,386 @@ err:
  */
 
 int
-dict_set_flag (dict_t *this, char *key, int flag)
+dict_set_flag(dict_t *this, char *key, int flag)
 {
-        return _dict_modify_flag (this, key, flag, DICT_FLAG_SET);
+    return _dict_modify_flag(this, key, flag, DICT_FLAG_SET);
 }
 
 int
-dict_clear_flag (dict_t *this, char *key, int flag)
+dict_clear_flag(dict_t *this, char *key, int flag)
 {
-        return _dict_modify_flag (this, key, flag, DICT_FLAG_CLEAR);
+    return _dict_modify_flag(this, key, flag, DICT_FLAG_CLEAR);
 }
 
-
 int
-dict_get_double (dict_t *this, char *key, double *val)
+dict_get_double(dict_t *this, char *key, double *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_DOUBLE, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_DOUBLE, key, -EINVAL);
 
-        ret = data_to_double_ptr (data, val);
+    ret = data_to_double_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
 int
-dict_set_double (dict_t *this, char *key, double val)
+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_double (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_set_static_ptr (dict_t *this, char *key, void *ptr)
+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_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_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;
 
-        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_get_ptr(dict_t *this, char *key, void **ptr)
 {
-        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;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
 
-        ret = data_to_ptr_common (data, ptr);
-        if (ret != 0) {
-                goto err;
-        }
+    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;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
 
-	*len = data->len;
+    *len = data->len;
 
-        ret = data_to_ptr_common (data, ptr);
-        if (ret != 0) {
-                goto err;
-        }
+    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;
-        }
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    if (!str) {
+        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);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
 
-        *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_set_dynstr(dict_t *this, char *key, char *str)
+{
+    const int keylen = strlen(key);
+    return dict_set_dynstrn(this, key, keylen, str);
+}
+
+int
+dict_set_dynstrn(dict_t *this, char *key, const int keylen, char *str)
+{
+    data_t *data = data_from_dynstr(str);
+    int ret = 0;
+
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
+
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
+
+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)
+dict_set_option(dict_t *this, char *key, char *str)
 {
-        data_t *data = NULL;
-        int     ret  = 0;
+    data_t *data = data_from_dynstr(str);
+    int ret = 0;
 
-        data = data_from_dynstr (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    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);
+    data->data_type = GF_DATA_TYPE_STR_OLD;
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_add_dynstr_with_alloc (dict_t *this, char *key, char *str)
+dict_add_dynstr_with_alloc(dict_t *this, char *key, char *str)
 {
-        data_t  *data = NULL;
-        int      ret  = 0;
-        char    *alloc_str = NULL;
+    data_t *data = NULL;
+    int ret = 0;
+    char *alloc_str = gf_strdup(str);
 
-        alloc_str = gf_strdup (str);
-        if (!alloc_str)
-                goto out;
+    if (!alloc_str)
+        goto out;
 
-        data = data_from_dynstr (alloc_str);
-        if (!data) {
-                GF_FREE (alloc_str);
-                ret = -EINVAL;
-                goto out;
-        }
+    data = data_from_dynstr(alloc_str);
+    if (!data) {
+        GF_FREE(alloc_str);
+        ret = -EINVAL;
+        goto out;
+    }
 
-        ret = dict_add (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_add(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dict_get_bin (dict_t *this, char *key, void **bin)
+dict_get_bin(dict_t *this, char *key, void **bin)
 {
-        data_t * data = NULL;
-        int      ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !bin) {
-                goto err;
-        }
+    if (!bin) {
+        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_PTR, key, ret);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, ret);
 
-        *bin = data->data;
+    *bin = data->data;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 /********************************************************************
@@ -2623,35 +2619,35 @@ err:
  *
  *******************************************************************/
 static int
-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)
+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 > DICT_KEY_VALUE_MAX_SIZE)) {
-                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->data_type = type;
+    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;
 }
 
 /********************************************************************
@@ -2662,10 +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,
-                                    GF_DATA_TYPE_PTR);
+    return dict_set_bin_common(this, key, ptr, size, _gf_false,
+                               GF_DATA_TYPE_PTR);
 }
 
 /********************************************************************
@@ -2676,77 +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);
+    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)
+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);
+    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)
+dict_get_gfuuid(dict_t *this, char *key, uuid_t *gfid)
 {
-        data_t *data = NULL;
-        int     ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !gfid) {
-                goto err;
-        }
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    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);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_GFUUID, key, -EINVAL);
 
-        memcpy (*gfid, data->data, min(data->len, sizeof (uuid_t)));
+    memcpy(*gfid, data->data, min(data->len, sizeof(uuid_t)));
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_set_iatt (dict_t *this, char *key, struct iatt *iatt, bool is_static)
+dict_set_mdata(dict_t *this, char *key, struct mdata_iatt *mdata,
+               bool is_static)
 {
-        return dict_set_bin_common (this, key, iatt, sizeof (struct iatt),
-                                    is_static, GF_DATA_TYPE_IATT);
+    return dict_set_bin_common(this, key, mdata, sizeof(struct mdata_iatt),
+                               is_static, GF_DATA_TYPE_MDATA);
 }
 
 int
-dict_get_iatt (dict_t *this, char *key, struct iatt *iatt)
+dict_get_mdata(dict_t *this, char *key, struct mdata_iatt *mdata)
 {
-        data_t *data = NULL;
-        int     ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !iatt) {
-                goto err;
-        }
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    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_IATT, key, -EINVAL);
+    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 (iatt, data->data, min(data->len, sizeof (struct iatt)));
+    memcpy(mdata, data->data, min(data->len, sizeof(struct mdata_iatt)));
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
+}
+
+int
+dict_set_iatt(dict_t *this, char *key, struct iatt *iatt, bool is_static)
+{
+    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.
@@ -2772,65 +2806,76 @@ err:
  */
 
 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;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        if (ret == -ENOENT)
+            ret = default_val;
+        else
+            ret = -1;
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    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;
 }
 
 /**
@@ -2841,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.
@@ -2855,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;
-        }
+    int ret = -EINVAL;
+    int count = this->count;
+    const int keyhdrlen = DICT_DATA_HDR_KEY_LEN + DICT_DATA_HDR_VAL_LEN;
 
-        pair = this->members_list;
+    if (count < 0) {
+        gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_COUNT_LESS_THAN_ZERO,
+                "count=%d", count, NULL);
+        goto out;
+    }
 
-        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;
-                }
-
-                len += strlen (pair->key) + 1  /* for '\0' */;
-
-                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;
 }
 
 /**
@@ -2927,86 +2925,74 @@ out:
  *          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
  *
@@ -3016,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;
 }
 
 /**
@@ -3048,26 +3034,25 @@ out:
  */
 
 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
  *
@@ -3080,138 +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;
-        }
-
-        if (size == 0) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "size is 0!");
-                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 (!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->data_type = GF_DATA_TYPE_STR_OLD;
-                value->is_static = 0;
-                buf += vallen;
-
-                ret = dict_add (*fill, key, value);
-                if (ret < 0)
-                        goto out;
-        }
+        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
  *
@@ -3224,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;
 }
 
 /**
@@ -3278,239 +3262,228 @@ out:
  *            : -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;
+    int ret = 0;
+    int dumplen = 0;
+    data_pair_t *trav = NULL;
 
-        if (!dict)
-                return 0;
+    if (!dict)
+        return 0;
 
-        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;
+    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;
 
-                dumplen += ret;
-        }
-        return 0;
+        dumplen += ret;
+    }
+    return 0;
 }
 
 void
-dict_dump_to_log (dict_t *dict)
-{
-        int          ret                       = -1;
-        char        *dump                      = NULL;
-        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_CALLOC (1, 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_msg ("dict", GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
-                        "Failed to log dictionary");
-                goto out;
-        }
-        gf_msg ("dict", GF_LOG_INFO, 0, LG_MSG_DICT_ERROR,
-                "dict=%p (%s)", dict, dump);
+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);
-
+    GF_FREE(dump);
 
-        return;
+    return;
 }
 
 void
-dict_dump_to_statedump (dict_t *dict, char *dict_name, char *domain)
-{
-        int          ret                       = -1;
-        char        *dump                      = NULL;
-        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_CALLOC (1, 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_msg (domain, GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
-                        "Failed to log dictionary %s", dict_name);
-                goto out;
-        }
-        gf_proc_dump_build_key (key, domain, "%s", dict_name);
-        gf_proc_dump_write (key, "%s", dump);
+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);
 
 out:
-        GF_FREE (dump);
+    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 52b6c8c62fe..00000000000
--- a/libglusterfs/src/dict.h
+++ /dev/null
@@ -1,293 +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)
-
-#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
-
-struct _data {
-        unsigned char  is_static:1;
-        unsigned char  is_const:1;
-        int32_t        len;
-        char          *data;
-        gf_atomic_t    refcount;
-        gf_lock_t      lock;
-        gf_dict_data_type_t data_type;
-};
-
-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;
-        gf_atomic_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;
-        uint64_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);
-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);
-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_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_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_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_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);
-
-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);
-
-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 8ff66a8445f..fb4fb845b40 100644
--- a/libglusterfs/src/event-epoll.c
+++ b/libglusterfs/src/event-epoll.c
@@ -8,761 +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 "gf-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;
-	gf_atomic_t 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;
+    table = event_pool->ereg[table_idx];
+    if (!table)
+        return NULL;
 
-	slot = &table[offset];
-        GF_ATOMIC_INC (slot->ref);
+    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;
-
-        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);
+    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 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);
-	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);
-
-        /* 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);
-
-	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;
+        }
 
-        ret = 0;
+        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);
-                if (ret) {
-                        gf_msg ("epoll", GF_LOG_ERROR, 0,
-                                LG_MSG_EXITED_EPOLL_THREAD,
-                                "Failed to dispatch handler");
-                }
+        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 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;
-
-                        snprintf (thread_name, sizeof(thread_name),
-                                  "epoll%03hx", (i & 0x3ff));
-                        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;
 }
 
 /**
@@ -775,89 +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),
-                                                  "epoll%03hx", (i & 0x3ff));
-                                        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
@@ -865,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 283e2861b2b..2cba963f096 100644
--- a/libglusterfs/src/event-poll.c
+++ b/libglusterfs/src/event-poll.c
@@ -16,497 +16,465 @@
 #include <errno.h>
 #include <string.h>
 
-#include "logging.h"
-#include "gf-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;
+    }
 
-        /* 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;
+    if (eventthreadcount > 1) {
+        gf_smsg("poll", GF_LOG_INFO, 0, LG_MSG_POLL_IGNORE_MULTIPLE_THREADS,
+                "count=%d", eventthreadcount, NULL);
+    }
 
-        return event_pool;
-}
+    /* 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;
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                if (event_pool->changed == 0) {
-                        goto unlock;
-                }
+    int i = 0;
 
-                if (event_pool->used > event_pool->evcache_size) {
-                        GF_FREE (event_pool->evcache);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        if (event_pool->changed == 0) {
+            goto unlock;
+        }
 
-                        event_pool->evcache = ufds = NULL;
+        if (event_pool->used > event_pool->evcache_size) {
+            GF_FREE(event_pool->evcache);
 
-                        event_pool->evcache_size = event_pool->used;
+            event_pool->evcache = ufds = NULL;
 
-                        ufds = GF_CALLOC (sizeof (struct pollfd),
-                                          event_pool->evcache_size,
-                                          gf_common_mt_pollfd);
-                        if (!ufds)
-                                goto unlock;
-                        event_pool->evcache = ufds;
-                }
+            event_pool->evcache_size = event_pool->used;
 
-                if (ufds == NULL) {
-                        goto unlock;
-                }
+            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
@@ -514,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 2598cd305a8..402c253ca25 100644
--- a/libglusterfs/src/event.c
+++ b/libglusterfs/src/event.c
@@ -16,184 +16,174 @@
 #include <errno.h>
 #include <string.h>
 
-#include "logging.h"
-#include "gf-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 succeed
@@ -204,109 +194,112 @@ out:
  *   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);
-                        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);
-
-        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/events.c b/libglusterfs/src/events.c
index 5a1b4c06e57..33157549897 100644
--- a/libglusterfs/src/events.c
+++ b/libglusterfs/src/events.c
@@ -19,118 +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;
-                goto out;
-        }
-
-        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 e516f64bff6..c2d34f81c9c 100644
--- a/libglusterfs/src/fd-lk.c
+++ b/libglusterfs/src/fd-lk.c
@@ -8,435 +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);
 
-        ref = GF_ATOMIC_DEC (lk_ctx->ref);
-        if (ref < 0)
-                GF_ASSERT (!ref);
-        if (ref == 0)
-                _fd_lk_destroy_lock_list (lk_ctx);
+    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;
+    return -1;
 }
 
 fd_lk_ctx_t *
-fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx)
+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;
-        }
+    if (!lk_ctx) {
+        gf_msg_callingfn("fd-lk", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (lk_ctx->ref);
+    GF_ATOMIC_INC(lk_ctx->ref);
 
-        return 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 11d864dc207..00000000000
--- a/libglusterfs/src/fd-lk.h
+++ /dev/null
@@ -1,65 +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;
-        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/fd.c b/libglusterfs/src/fd.c
index 01e292cc107..62606e91164 100644
--- a/libglusterfs/src/fd.c
+++ b/libglusterfs/src/fd.c
@@ -8,1226 +8,1196 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "fd.h"
-#include "glusterfs.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_rwlock_init (&fdtable->lock, NULL);
+    pthread_rwlock_init(&fdtable->lock, NULL);
 
-        pthread_rwlock_wrlock (&fdtable->lock);
-        {
-                gf_fd_fdtable_expand (fdtable, 0);
-        }
-        pthread_rwlock_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_rwlock_wrlock (&fdtable->lock);
-                {
-                        entries = __gf_fd_fdtable_get_all_fds (fdtable, count);
-                }
-                pthread_rwlock_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_rwlock_rdlock (&fdtable->lock);
-                {
-                        entries = __gf_fd_fdtable_copy_all_fds (fdtable, count);
-                }
-                pthread_rwlock_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_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);
-        }
+    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_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;
-                }
-        }
+    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_rwlock_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;
+    fd_t *fdptr = NULL;
+    fdentry_t *fde = NULL;
 
-        if (fd == GF_ANON_FD_NO)
-                return;
-
-        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_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;
-        }
+    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_rwlock_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_rwlock_wrlock (&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_rwlock_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_rwlock_rdlock (&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_rwlock_unlock (&fdtable->lock);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fdptr;
+    return fdptr;
 }
 
-
 fd_t *
-__fd_ref (fd_t *fd)
+__fd_ref(fd_t *fd)
 {
-        GF_ATOMIC_INC (fd->refcount);
+    GF_ATOMIC_INC(fd->refcount);
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_ref (fd_t *fd)
+fd_ref(fd_t *fd)
 {
-        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;
+    }
 
-        GF_ATOMIC_INC (fd->refcount);
+    GF_ATOMIC_INC(fd->refcount);
 
-        return fd;
+    return fd;
 }
 
-
 static void
-fd_destroy (fd_t *fd, gf_boolean_t bound)
+fd_destroy(fd_t *fd, gf_boolean_t bound)
 {
-        xlator_t    *xl = NULL;
-        int          i = 0;
-        xlator_t    *old_THIS = NULL;
+    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;
+}
 
-        if (fd == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR,  EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                goto out;
-        }
+void
+fd_close(fd_t *fd)
+{
+    xlator_t *xl, *old_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;
+    old_THIS = THIS;
+
+    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->call_cleanup && 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->call_cleanup && 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);
-        {
-                refcount = GF_ATOMIC_DEC (fd->refcount);
-                if (refcount == 0) {
-                        if (!list_empty (&fd->inode_list)) {
-                                list_del_init (&fd->inode_list);
-                                fd->inode->active_fd_count--;
-                                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++;
-        fd->inode->active_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;
-
-        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_t *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 won't 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;
-}
-
-
-fd_t *
-fd_anonymous (inode_t *inode)
-{
-        fd_t *fd = NULL;
+    UNLOCK(&inode->lock);
 
-        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;
-
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
+    fd_t *fd = 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;
-                        /* don't 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_rwlock_tryrdlock (&fdtable->lock);
-        if (ret)
-                goto out;
+    ret = pthread_rwlock_tryrdlock(&fdtable->lock);
+    if (ret)
+        goto out;
 
-        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);
-                }
+    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("%s", key);
+            fdentry_dump(&fdtable->fdentries[i], key);
         }
+    }
 
-        pthread_rwlock_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;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int ret = -1;
 
-        if (!fdentry)
-                return;
-        if (!dict)
-                return;
+    if (!fdentry)
+        return;
+    if (!dict)
+        return;
 
-        if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
-                return;
+    if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
+        return;
 
-        if (fdentry->fd) {
-                snprintf (key, sizeof (key), "%s.pid", prefix);
-                ret = dict_set_uint64 (dict, key, fdentry->fd->pid);
-                if (ret)
-                        return;
+    if (fdentry->fd) {
+        snprintf(key, sizeof(key), "%s.pid", prefix);
+        ret = dict_set_uint64(dict, key, fdentry->fd->pid);
+        if (ret)
+            return;
 
-                snprintf (key, sizeof (key), "%s.refcount", prefix);
-                ret = dict_set_int32 (dict, key, GF_ATOMIC_GET (fdentry->fd->refcount));
-                if (ret)
-                        return;
+        snprintf(key, sizeof(key), "%s.refcount", prefix);
+        ret = dict_set_int32(dict, key, GF_ATOMIC_GET(fdentry->fd->refcount));
+        if (ret)
+            return;
 
-                snprintf (key, sizeof (key), "%s.flags", prefix);
-                ret = dict_set_int32 (dict, key, fdentry->fd->flags);
+        snprintf(key, sizeof(key), "%s.flags", prefix);
+        ret = dict_set_int32(dict, key, fdentry->fd->flags);
+        if (ret)
+            return;
 
-                (*openfds)++;
-        }
-        return;
+        (*openfds)++;
+    }
+    return;
 }
 
 void
-fdtable_dump_to_dict (fdtable_t *fdtable, char *prefix, dict_t *dict)
+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;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int i = 0;
+    int openfds = 0;
+    int ret = -1;
+
+    if (!fdtable)
+        return;
+    if (!dict)
+        return;
 
-        if (!fdtable)
-                return;
-        if (!dict)
-                return;
+    ret = pthread_rwlock_tryrdlock(&fdtable->lock);
+    if (ret)
+        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.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.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;
+    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);
-                }
+    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);
         }
+    }
 
-        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_rwlock_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 3f68b1c4997..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;
-        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 "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 0c96fd0c176..e31d3a9fe8a 100644..100755
--- a/libglusterfs/src/gen-defaults.py
+++ b/libglusterfs/src/gen-defaults.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 from __future__ import print_function
 import sys
diff --git a/libglusterfs/src/generator.py b/libglusterfs/src/generator.py
index 64db4e8c479..5b7aa4764a0 100755
--- a/libglusterfs/src/generator.py
+++ b/libglusterfs/src/generator.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 
 import string
 
@@ -599,6 +599,19 @@ ops['namelink'] = (
 	('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 *'),
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/gf-event.h b/libglusterfs/src/gf-event.h
deleted file mode 100644
index 55a74ed17c6..00000000000
--- a/libglusterfs/src/gf-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 _GF_EVENT_H_
-#define _GF_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 /* _GF_EVENT_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 78fd22ee252..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store.c
+++ /dev/null
@@ -1,882 +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;
-                goto out;
-                /*TODO What if the unlock fails.
-                * Will it lead to deadlock?
-                * Most of the gluster code
-                * no check for unlock or destroy 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 destroy 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 connection 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.");
-                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");
-                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 separate 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 length 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 93bdda813a9..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 separate 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 length 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 d5cfb24eeba..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));
-
-                /* Resetting 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 7e81aab08a6..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)();
-
-
-
-
-/* Function 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 f20ae4ded78..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 consistency 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 ad94d648369..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 performance */
-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 performance */
-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 function 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 function 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 function 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 function 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 function 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 length 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 length 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 switch?
- * 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 11bf3e82707..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);
-
-        /*Extract 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 length 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 length 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 switch?
- * 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 b2c3392f45a..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" : "";
-
-                        /*Perfectly 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 {
-                        /*Perfectly 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" : "";
-
-                        /*Perfectly 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 {
-                        /*Perfectly 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 don't
-                                 * 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 don't 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 f991ce142d4..00000000000
--- a/libglusterfs/src/glfs-message-id.h
+++ /dev/null
@@ -1,97 +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
-
-/* 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),
-
-/* --- new segments for messages goes above this line --- */
-
-        GLFS_MSGID_END
-};
-
-#endif /* !_GLFS_MESSAGE_ID_H_ */
diff --git a/libglusterfs/src/globals.c b/libglusterfs/src/globals.c
index 3506d482bda..ae06f8be386 100644
--- a/libglusterfs/src/globals.c
+++ b/libglusterfs/src/globals.c
@@ -10,84 +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_PUT]         = "PUT",
-        [GF_FOP_ICREATE]     = "ICREATE",
-        [GF_FOP_NAMELINK]    = "NAMELINK",
+    [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 */
@@ -98,464 +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,
 };
 
 /* This is required to get through the check in graph.c */
-static struct xlator_fops global_fops = {
-};
+static struct xlator_fops global_fops = {};
 
 static int
-global_xl_reconfigure (xlator_t *this, dict_t *options)
+global_xl_reconfigure(xlator_t *this, dict_t *options)
 {
-        int ret = -1;
-        gf_boolean_t bool_opt = _gf_false;
+    int ret = -1;
+    gf_boolean_t bool_opt = _gf_false;
 
-        /* This is not added in volume dump, hence adding the options in log
-           would be helpful for debugging later */
-        dict_dump_to_log (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);
 
-        GF_OPTION_RECONF ("measure-latency", bool_opt, options, bool, out);
-        this->ctx->measure_latency = bool_opt;
+    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);
+    GF_OPTION_RECONF("metrics-dump-path", this->ctx->config.metrics_dumppath,
+                     options, str, out);
 
-        /* TODO: add more things here */
-        ret = 0;
+    /* TODO: add more things here */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-global_xl_init (xlator_t *this)
+global_xl_init(xlator_t *this)
 {
-        int ret = -1;
-        gf_boolean_t bool_opt = false;
+    int ret = -1;
+    gf_boolean_t bool_opt = false;
 
-        GF_OPTION_INIT ("measure-latency", bool_opt, bool, out);
-        this->ctx->measure_latency = bool_opt;
+    GF_OPTION_INIT("measure-latency", bool_opt, bool, out);
+    this->ctx->measure_latency = bool_opt;
 
-        GF_OPTION_INIT ("metrics-dump-path", this->ctx->config.metrics_dumppath,
-                        str, out);
+    GF_OPTION_INIT("metrics-dump-path", this->ctx->config.metrics_dumppath, str,
+                   out);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 static void
-global_xl_fini (xlator_t *this)
+global_xl_fini(xlator_t *this)
 {
-        return;
+    return;
 }
 
 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},},
+    {.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},
+    },
 };
 
 static volume_opt_list_t global_xl_opt_list;
 
-int
-glusterfs_this_init ()
+void
+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;
-        }
-
-        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);
-
-        return ret;
+    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);
 }
 
-
 xlator_t **
-__glusterfs_this_location ()
+__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;
-                }
-        }
-out:
-        if (this_location) {
-                if (!*this_location)
-                        *this_location = &global_xlator;
-        }
-        return this_location;
-}
+    xlator_t **this_location;
 
+    this_location = &thread_xlator;
+    if (*this_location == NULL) {
+        thread_xlator = &global_xlator;
+    }
+
+    return this_location;
+}
 
 xlator_t *
-glusterfs_this_get ()
+glusterfs_this_get()
 {
-        xlator_t **this_location = NULL;
-
-        this_location = __glusterfs_this_location ();
-        if (!this_location)
-                return &global_xlator;
-
-        return *this_location;
+    return *__glusterfs_this_location();
 }
 
-
-int
-glusterfs_this_set (xlator_t *this)
+void
+glusterfs_this_set(xlator_t *this)
 {
-        xlator_t **this_location = NULL;
-
-        this_location = __glusterfs_this_location ();
-        if (!this_location)
-                return -ENOMEM;
-
-        *this_location = this;
-
-        return 0;
+    thread_xlator = this;
 }
 
 /* SYNCOPCTX */
-static pthread_key_t syncopctx_key;
-
-static void
-syncopctx_key_destroy (void *ptr)
-{
-	struct syncopctx *opctx = ptr;
-
-	if (opctx) {
-		if (opctx->groups)
-			GF_FREE (opctx->groups);
-
-		GF_FREE (opctx);
-	}
-
-	return;
-}
 
 void *
-syncopctx_getctx ()
+syncopctx_getctx()
 {
-	void *opctx = NULL;
-
-	opctx = pthread_getspecific (syncopctx_key);
-
-	return opctx;
-}
-
-int
-syncopctx_setctx (void *ctx)
-{
-	int ret = 0;
-
-	ret = pthread_setspecific (syncopctx_key, ctx);
-
-	return ret;
-}
-
-static int
-syncopctx_init (void)
-{
-	int ret;
-
-	ret = pthread_key_create (&syncopctx_key, syncopctx_key_destroy);
-
-	return ret;
+    return &thread_syncopctx;
 }
 
 /* SYNCTASK */
 
-int
-synctask_init ()
-{
-        int  ret = 0;
-
-        ret = pthread_key_create (&synctask_key, NULL);
-
-        return ret;
-}
-
 void *
-synctask_get ()
-{
-        void   *synctask = NULL;
-
-        synctask = pthread_getspecific (synctask_key);
-
-        return synctask;
-}
-
-
-int
-synctask_set (void *synctask)
+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;
 
-/* Leaseid buffer */
-void
-glusterfs_leaseid_buf_destroy (void *ptr)
-{
-        FREE (ptr);
+    buf = thread_leaseid;
+    if (buf == NULL) {
+        buf = thread_leaseid_buf;
+        thread_leaseid = buf;
+    }
+
+    return buf;
 }
 
-int
-glusterfs_leaseid_buf_init ()
+char *
+glusterfs_leaseid_exist()
 {
-        int ret = 0;
-
-        ret = pthread_key_create (&leaseid_buf_key,
-                                  glusterfs_leaseid_buf_destroy);
-        return ret;
+    return thread_leaseid;
 }
 
-char *
-glusterfs_leaseid_buf_get ()
+static void
+glusterfs_cleanup(void *ptr)
 {
-        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;
+    if (thread_syncopctx.groups != NULL) {
+        GF_FREE(thread_syncopctx.groups);
+    }
+
+    mem_pool_thread_destructor(NULL);
 }
 
-char *
-glusterfs_leaseid_exist ()
+void
+gf_thread_needs_cleanup(void)
 {
-        return pthread_getspecific (leaseid_buf_key);
+    /* 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 fb1f839b259..00000000000
--- a/libglusterfs/src/globals.h
+++ /dev/null
@@ -1,157 +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 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_4_2_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_4_2_0    40200 /* Op-version for GlusterFS 4.2.0 */
-
-#define GD_OP_VER_PERSISTENT_AFR_XATTRS GD_OP_VERSION_3_6_0
-
-#include "xlator.h"
-#include "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);
-int glusterfs_this_set (xlator_t *);
-
-extern xlator_t global_xlator;
-extern struct volume_options global_xl_options[];
-
-/* 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);
-char *glusterfs_leaseid_exist (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 7dd3b06a468..00000000000
--- a/libglusterfs/src/glusterfs.h
+++ /dev/null
@@ -1,764 +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 */
-
-#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)))
-#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))
-#endif
-
-#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
-
-/*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  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 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,      \
-                                        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 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"
-
-/* 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 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_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 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 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 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_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_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"
-
-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;
-
-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 (pri < 0)
-                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
-
-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;
-        /* 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              *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;
-};
-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 */
-
-        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_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;
-};
-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);
-
-int glusterfs_read_secure_access_file (void);
-#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 677a59aa91e..019bb14df71 100644
--- a/libglusterfs/src/checksum.h
+++ b/libglusterfs/src/glusterfs/checksum.h
@@ -12,11 +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);
+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 2e66117ce1f..6e7fdefbfab 100644
--- a/libglusterfs/src/compat-uuid.h
+++ b/libglusterfs/src/glusterfs/compat-uuid.h
@@ -11,58 +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);
 }
 
-#elif defined(__FreeBSD__)
-
-#error Please install e2fsprogs-libuuid for a compatible libuuid implementation.
-
 /* TODO: add more uuid APIs, use constructs like this:
-#elif defined(__NetBSD__) * NetBSD libc *
+#if defined(__NetBSD__) * NetBSD libc *
 
 #include <string.h>
 
@@ -71,8 +65,7 @@ gf_uuid_clear (uuid_t uuid)
 {
         memset (uuid, 0, sizeof (uuid_t));
 }
-
+#endif
 */
 
-#endif /* HAVE_UUID */
 #endif /* _GF_UUID_H */
diff --git a/libglusterfs/src/compat.h b/libglusterfs/src/glusterfs/compat.h
index e0ffe73926a..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,32 +37,28 @@
 #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
@@ -72,14 +67,14 @@
  * '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,28 +181,29 @@ 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);
+void
+gf_extattr_list_reshape(char *list, ssize_t size);
 
 #endif /* GF_BSD_HOST_OS */
 
@@ -226,14 +239,12 @@ void gf_extattr_list_reshape(char *list, ssize_t size);
 
 #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
@@ -253,24 +264,24 @@ void gf_extattr_list_reshape(char *list, ssize_t size);
 #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 */
 
@@ -291,107 +302,120 @@ void gf_extattr_list_reshape(char *list, ssize_t size);
 #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 */
 
@@ -402,52 +426,54 @@ 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 */
 
@@ -483,9 +509,15 @@ char *dirname_r(char *path);
 #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);
+#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
 
 #ifdef GF_BSD_HOST_OS
@@ -495,11 +527,15 @@ char *dirname_r(char *path);
 #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/monitoring.h b/libglusterfs/src/glusterfs/monitoring.h
index 1c08bfc7eb6..09d9f54e734 100644
--- a/libglusterfs/src/monitoring.h
+++ b/libglusterfs/src/glusterfs/monitoring.h
@@ -11,11 +11,11 @@
 #ifndef __MONITORING_H__
 #define __MONITORING_H__
 
-#include "glusterfs.h"
+#include "glusterfs/glusterfs.h"
 
 #define GLUSTER_METRICS_DIR "/var/run/gluster/metrics"
 
 char *
-gf_monitor_metrics (glusterfs_ctx_t *ctx);
+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 2186c155607..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,7 +51,7 @@ _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 -- initialize an embedded refcount object
  *
@@ -59,8 +59,7 @@ _gf_ref_put (gf_ref_t *ref);
  * @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/template-component-messages.h b/libglusterfs/src/glusterfs/template-component-messages.h
index 0f0062a5d7c..aa7ad3d1baa 100644
--- a/libglusterfs/src/template-component-messages.h
+++ b/libglusterfs/src/glusterfs/template-component-messages.h
@@ -11,7 +11,7 @@
 #ifndef _component_MESSAGES_H_
 #define _component_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.
  *
@@ -23,10 +23,6 @@
  * glfs-message-id.h.
  */
 
-GLFS_MSGID(component,
-        message id,
-        message id,
-        ...
-);
+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 2a171f3b8dc..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 <regex.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, }, };
@@ -69,623 +85,647 @@ _gf_dump_details (int argc, char **argv)
 #endif
 
 int
-glusterfs_read_secure_access_file (void)
+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);
+    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;
+    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;
 }
 
 /*
@@ -703,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 (!trav1->cleanup_starting && !strcmp (trav1->name, trav2->name)) {
-                                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
@@ -934,183 +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;
-        }
-
-        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");
+    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;
-                }
-
-                /*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;
+        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;
         }
 
-        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);
+    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);
         }
+    }
 
-        /* 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);
-                }
-        }
-
-        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
@@ -1136,138 +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;
-        volfile_content = GF_CALLOC (file_len+1, sizeof (char),
-                                     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;
+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;
         }
-
-        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;
+    }
+    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;
         }
+    }
 
-        GF_FREE (volfile_content);
+    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);
 
-        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;
+    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;
+}
 
-        /*
-         * 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);
+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;
+}
+
+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;
+}
+
+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;
         }
-
-        /* 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;
+    }
+
+    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 3c3f7b5bb82..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);
@@ -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;
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 500ccb01324..00000000000
--- a/libglusterfs/src/iatt.h
+++ /dev/null
@@ -1,470 +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_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;
-};
-
-/* 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 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);
-
-        /* 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/inode.c b/libglusterfs/src/inode.c
index 488486f35b8..dbadf77442d 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -8,696 +8,707 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "inode.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);
-        list_del_init (&dentry->parent_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;
 
-        dentry->inode = 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->call_cleanup && 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);
-        INIT_LIST_HEAD (&newd->parent_list);
+    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);
-        list_add (&newd->parent_list, &parent->children);
+    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->children);
+    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
@@ -708,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 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.
+    /* 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:
@@ -1952,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:
@@ -2220,350 +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("active-fd-count", "%u",
-                                   inode->active_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;
 
-        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;
 
-        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;
 
-        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;
 
-        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;
-
-        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;
-
-        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;
+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) {
-                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;
 }
 
 /* *
@@ -2573,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 96f67c05629..00000000000
--- a/libglusterfs/src/inode.h
+++ /dev/null
@@ -1,294 +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 "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 */
-        struct list_head   parent_list;  /* list of parent's children */
-        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             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 list_head     children;      /* list of children */
-
-        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)
-#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/iobuf.c b/libglusterfs/src/iobuf.c
index 0ca272986a1..4e7d2958764 100644
--- a/libglusterfs/src/iobuf.c
+++ b/libglusterfs/src/iobuf.c
@@ -8,1255 +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;
+    int i;
 
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                if (page_size <= gf_iobuf_init_config[i].pagesize)
-                        break;
-        }
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        if (page_size <= gf_iobuf_init_config[i].pagesize)
+            return i;
+    }
 
-        if (i >= IOBUF_ARENA_MAX_INDEX)
-                i = -1;
-
-        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;
+    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_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;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
+    int iobuf_cnt = 0;
+    struct iobuf *iobuf = NULL;
+    int i = 0;
 
-        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 = iobuf_arena->iobufs;
-        for (i = 0; i < iobuf_cnt; i++) {
-                GF_ASSERT (GF_ATOMIC_GET(iobuf->ref) == 0);
+    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);
 
-                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 allocated 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 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;
 
-        /* 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;
+    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;
         }
+    }
 
-        /* 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);
-        }
+    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);
+    }
 
-out:
-        return iobuf_arena;
+    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;
+    struct iobuf *iobuf = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-
-        iobuf_pool = iobuf_arena->iobuf_pool;
-
-        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 */
-        GF_ATOMIC_INIT (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;
-
-        req_size = page_size;
+    size_t req_size = 0;
+    struct iobuf *iobuf = NULL;
 
-        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);
 
-        ref = GF_ATOMIC_DEC (iobuf->ref);
+    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);
-        GF_ATOMIC_INC (iobuf->ref);
+    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 = GF_MALLOC(sizeof(*iobref), 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->iobrefs = GF_CALLOC(sizeof(*iobref->iobrefs), 16,
+                                gf_common_mt_iobrefs);
+    if (!iobref->iobrefs) {
+        GF_FREE(iobref);
+        return NULL;
+    }
 
-	iobref->allocated = 16;
-	iobref->used = 0;
+    iobref->allocated = 16;
+    iobref->used = 0;
 
-        LOCK_INIT (&iobref->lock);
+    LOCK_INIT(&iobref->lock);
 
-        GF_ATOMIC_INIT (iobref->ref, 1);
-        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);
-        GF_ATOMIC_INC (iobref->ref);
+    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->allocated; 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;
+    int ref = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        ref = GF_ATOMIC_DEC (iobref->ref);
+    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->allocated; i++) {
-                if (iobref->iobrefs[i] != NULL) {
-                        iobuf_unref (iobref->iobrefs[i]);
-                } else {
-                        /** iobuf's are attached 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->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;
-	}
+    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;
+    int i = 0;
+    int ret = -ENOMEM;
 
-        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);
 
-	if (iobref->used == iobref->allocated) {
-		__iobref_grow (iobref);
+    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;
-                }
+        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->allocated; 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->allocated; 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)
+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;
+    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;
+    return ret;
 }
diff --git a/libglusterfs/src/iobuf.h b/libglusterfs/src/iobuf.h
deleted file mode 100644
index 21184da1d2e..00000000000
--- a/libglusterfs/src/iobuf.h
+++ /dev/null
@@ -1,182 +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 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 */
-
-        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;
-        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/latency.c b/libglusterfs/src/latency.c
index fb3b155caa6..ce4b0e8255d 100644
--- a/libglusterfs/src/latency.c
+++ b/libglusterfs/src/latency.c
@@ -8,95 +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 "xlator.h"
-#include "common-utils.h"
-#include "statedump.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/statedump.h"
 
-void
-gf_update_latency (call_frame_t *frame)
+gf_latency_t *
+gf_latency_new(size_t n)
 {
-        double elapsed;
-        struct timespec *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;
 
-        if (!(begin->tv_sec && end->tv_sec))
-                goto out;
-
-        elapsed = (end->tv_sec - begin->tv_sec) * 1e9
-                + (end->tv_nsec - begin->tv_nsec);
+    for (i = 0; i < n; i++) {
+        gf_latency_reset(lat + i);
+    }
+    return lat;
+}
 
-        if (frame->op < 0 || frame->op >= GF_FOP_MAXVALUE) {
-                gf_log ("[core]", GF_LOG_WARNING,
-                        "Invalid frame op value: %d",
-                        frame->op);
-                return;
-        }
+void
+gf_latency_update(gf_latency_t *lat, struct timespec *begin,
+                  struct timespec *end)
+{
+    if (!(begin->tv_sec && end->tv_sec)) {
+        /*Measure latency might have been enabled/disabled during the op*/
+        return;
+    }
 
-        /* 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;
+    double elapsed = gf_tsdiff(begin, end);
 
-        lat = &frame->this->stats.interval.latencies[frame->op];
+    if (lat->max < elapsed)
+        lat->max = elapsed;
 
-        if (lat->max < elapsed)
-                lat->max = elapsed;
+    if (lat->min > elapsed)
+        lat->min = elapsed;
 
-        if (lat->min > elapsed)
-                lat->min = elapsed;
+    lat->total += elapsed;
+    lat->count++;
+}
 
-        lat->total += elapsed;
-        lat->count++;
-out:
+void
+gf_latency_reset(gf_latency_t *lat)
+{
+    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_proc_dump_latency_info (xlator_t *xl)
+gf_frame_latency_update(call_frame_t *frame)
 {
-        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]);
-
-                fop_latency_t *lat = &xl->stats.interval.latencies[i];
-
-                /* Doesn't make sense to continue if there are no fops
-                   came in the given interval */
-                if (!lat->count)
-                        continue;
-
-                gf_proc_dump_write (key, "%.03f,%"PRId64",%.03f",
-                                    (lat->total / lat->count), lat->count,
-                                    lat->total);
-        }
-
-        memset (xl->stats.interval.latencies, 0,
-                sizeof (xl->stats.interval.latencies));
+    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;
+    }
 
-        /* make sure 'min' is set to high value, so it would be
-           properly set later */
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                xl->stats.interval.latencies[i].min = 0xffffffff;
-        }
+    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 73a93242341..00000000000
--- a/libglusterfs/src/latency.h
+++ /dev/null
@@ -1,23 +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 {
-        double min;           /* min time for the call (microseconds) */
-        double max;           /* max time for the call (microseconds) */
-	double total;           /* total time (microseconds) */
-        uint64_t count;
-} fop_latency_t;
-
-#endif /* __LATENCY_H__ */
diff --git a/libglusterfs/src/libglusterfs-messages.h b/libglusterfs/src/libglusterfs-messages.h
deleted file mode 100644
index ad7d69e6b4c..00000000000
--- a/libglusterfs/src/libglusterfs-messages.h
+++ /dev/null
@@ -1,242 +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"
-
-/* 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
-);
-
-#endif /* !_LG_MESSAGES_H_ */
-
diff --git a/libglusterfs/src/libglusterfs.sym b/libglusterfs/src/libglusterfs.sym
index ca952d51942..5f18cd56cbe 100644
--- a/libglusterfs/src/libglusterfs.sym
+++ b/libglusterfs/src/libglusterfs.sym
@@ -92,6 +92,8 @@ 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
@@ -127,10 +129,6 @@ cluster_uninodelk
 cluster_unlink
 cluster_xattrop
 cluster_xattrop_cbk
-compound_args_cbk_alloc
-compound_args_cbk_cleanup
-compound_args_cleanup
-compound_fop_alloc
 copy_opts_to_child
 create_frame
 data_copy
@@ -351,14 +349,19 @@ default_put
 default_put_cbk
 default_put_failure_cbk
 default_put_resume
-__dentry_grep
+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
@@ -367,17 +370,21 @@ 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
@@ -394,22 +401,30 @@ 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
@@ -423,19 +438,20 @@ eh_dump
 eh_new
 eh_save_history
 entry_copy
-event_dispatch
-event_dispatch_destroy
-event_handled
-event_pool_destroy
-event_pool_new
-event_reconfigure_threads
-event_register
-event_select_on
-event_unregister
-event_unregister_close
+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
@@ -460,6 +476,8 @@ 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
@@ -489,6 +507,7 @@ 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
@@ -528,14 +547,16 @@ get_checksum_for_path
 get_file_mtime
 get_host_name
 get_mem_size
-get_new_dict
 get_path_name
-get_struct_variable
-get_vol_type
 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
@@ -564,6 +585,7 @@ 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
@@ -672,10 +694,10 @@ 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
 gf_string2bytesize_int64
 gf_string2bytesize_uint64
 gf_string2double
@@ -693,7 +715,10 @@ 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
@@ -773,6 +798,7 @@ __inode_find
 inode_find
 inode_find_directory_name
 inode_forget
+inode_forget_with_unref
 inode_from_path
 inode_grep
 inode_grep_for_gfid
@@ -797,6 +823,7 @@ 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
@@ -849,8 +876,7 @@ mem_get0
 mem_pool_destroy
 mem_pool_new_fn
 mem_pools_fini
-mem_pools_init_early
-mem_pools_init_late
+mem_pools_init
 mem_put
 mkdir_p
 next_token
@@ -913,6 +939,12 @@ 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
@@ -923,6 +955,7 @@ synclock_unlock
 syncop_access
 syncop_close
 syncop_create
+syncop_copy_file_range
 syncopctx_getctx
 syncopctx_setfsgid
 syncopctx_setfsgroups
@@ -989,6 +1022,7 @@ synctask_new
 synctask_new1
 synctask_set
 synctask_setid
+synctask_sleep
 synctask_wake
 synctask_yield
 sys_access
@@ -996,6 +1030,7 @@ sys_chmod
 sys_chown
 sys_close
 sys_closedir
+sys_copy_file_range
 sys_creat
 sys_fallocate
 sys_fchmod
@@ -1013,6 +1048,7 @@ sys_futimes
 sys_lchown
 sys_lgetxattr
 sys_link
+sys_linkat
 sys_llistxattr
 sys_lremovexattr
 sys_lseek
@@ -1036,15 +1072,24 @@ 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
@@ -1065,6 +1110,7 @@ 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
@@ -1075,10 +1121,12 @@ 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
@@ -1087,10 +1135,12 @@ 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
@@ -1107,6 +1157,7 @@ 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
@@ -1122,3 +1173,21 @@ 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 a46cb234b72..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,167 +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 (glusterfs_ctx_t *ctx, gf_loglevel_t level)
+gf_log_set_loglevel(glusterfs_ctx_t *ctx, gf_loglevel_t level)
 {
-        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
@@ -206,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)
-{
-        THIS->ctx->log.timeout = timeout;
-}
-
-log_buf_t *
-log_buf_new ()
+gf_log_set_log_flush_timeout(uint32_t timeout)
 {
-        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);
-                }
-
-                fd = sys_open (ctx->log.filename, O_CREAT | O_WRONLY | O_APPEND,
-                               S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg ("logrotate", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open "
-                                "logfile");
-                        return;
-                }
+    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);
+        }
 
-                new_logfile = fdopen (fd, "a");
-                if (!new_logfile) {
-                        gf_msg ("logrotate", GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open logfile"
-                                " %s", ctx->log.filename);
-                        sys_close (fd);
-                        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
@@ -461,45 +380,44 @@ 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;
 
-        GF_FREE (ctx->log.ident);
-        GF_FREE (ctx->log.filename);
+    GF_FREE(ctx->log.ident);
+    GF_FREE(ctx->log.filename);
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
-
 /**
  * gf_openlog -function to open syslog specific to gluster based on
  *             existence of file /etc/glusterfs/logger.conf
@@ -511,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
@@ -556,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()
@@ -645,159 +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) {
-                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;
+    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;
+        }
+
+        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));
+            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;
+        }
+
+        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;
         }
 
-        /* free the (possible) previous filename */
-        GF_FREE (ctx->log.filename);
-        ctx->log.filename = 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;
-		}
-
-		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));
-                        sys_close (dupfd);
-			return -1;
-		}
-        } else {
-                ctx->log.filename = gf_strdup (file);
-                if (!ctx->log.filename) {
-                        fprintf (stderr, "ERROR: updating log-filename failed: "
-                                 "%s\n", strerror (errno));
-                        return -1;
-                }
-
-                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;
-                }
-
-                ctx->log.logfile = fdopen (fd, "a");
-                if (!ctx->log.logfile) {
-                        fprintf (stderr, "ERROR: failed to open logfile \"%s\" "
-                                 "(%s)\n", file, strerror (errno));
-                        sys_close (fd);
-                        return -1;
-                }
+        ctx->log.logfile = fdopen(fd, "a");
+        if (!ctx->log.logfile) {
+            fprintf(stderr,
+                    "ERROR: failed to open logfile \"%s\" "
+                    "(%s)\n",
+                    file, strerror(errno));
+            sys_close(fd);
+            return -1;
         }
+    }
 
-        ctx->log.gf_log_logfile = ctx->log.logfile;
+    ctx->log.gf_log_logfile = ctx->log.logfile;
 
-        return 0;
+    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
@@ -805,1844 +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 = sys_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 = sys_open (ctx->log.cmd_log_filename,
-                       O_CREAT | O_WRONLY | O_APPEND, 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;
         }
 
-        ctx->log.cmdlogfile = fdopen (fd, "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);
-                sys_close (fd);
-                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 = 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 "
-                                "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;
-                        sys_close (fd);
-                        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);
-
-        FREE (str2);
-
-        va_end (ap);
+    if (buffer)
+        GF_FREE(buffer);
 
-        return ret;
-}
-
-static 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 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);
-
-                        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;
-        }
+    if (tmp1)
+        GF_FREE(tmp1);
 
-        *msg = gf_strdup (tmp2);
-        if (!*msg)
-                ret = -1;
+    if (tmp2)
+        GF_FREE(tmp2);
 
- out:
-        if (buffer)
-                GF_FREE (buffer);
-
-        if (tmp1)
-                GF_FREE (tmp1);
-
-        if (tmp2)
-                GF_FREE (tmp2);
-
-        return ret;
+    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 94acd960b50..00000000000
--- a/libglusterfs/src/logging.h
+++ /dev/null
@@ -1,353 +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_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;
-        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, 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++%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_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, level, errnum, msgid, event...) do {              \
-                _gf_smsg (dom, __FILE__, __FUNCTION__, __LINE__,       \
-                          level, errnum, 0, msgid, ##event);           \
-        } while (0)
-
-#define gf_slog(dom, level, event...) do {                             \
-                _gf_slog (dom, __FILE__, __FUNCTION__, __LINE__,       \
-                          level, ##event);                             \
-        } while (0)
-
-#endif /* __LOGGING_H__ */
diff --git a/libglusterfs/src/mem-pool.c b/libglusterfs/src/mem-pool.c
index 4b140296b4f..2d5a12b0a00 100644
--- a/libglusterfs/src/mem-pool.c
+++ b/libglusterfs/src/mem-pool.c
@@ -8,897 +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>
 
 #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(&xl->mem_acct->rec[type].lock);
+        UNLOCK(&rec->lock);
 
-        GF_ATOMIC_INC (xl->mem_acct->refcnt);
+        /* 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);
+        }
+    }
 
-        header = (struct mem_header *) ptr;
-        header->type = type;
-        header->size = size;
-        header->mem_acct = xl->mem_acct;
-        header->magic = GF_MEM_HEADER_MAGIC;
+    header->type = type;
+    header->mem_acct = mem_acct;
+    header->magic = GF_MEM_HEADER_MAGIC;
 
-#ifdef DEBUG
-        INIT_LIST_HEAD(&header->acct_list);
-        LOCK(&xl->mem_acct->rec[type].lock);
+    return gf_mem_header_prepare(header, size);
+}
+
+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);
         {
-                list_add (&header->acct_list,
-                          &(xl->mem_acct->rec[type].obj_list));
-        }
-        UNLOCK(&xl->mem_acct->rec[type].lock);
+            rec->size += size - header->size;
+            rec->total_allocs++;
+            rec->max_size = max(rec->max_size, rec->size);
+
+#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
-        ptr += sizeof (struct mem_header);
-        /* data follows in this gap of 'size' bytes */
-        *(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
+        }
+        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;
+    size_t tot_size = 0;
+    struct mem_header *header = NULL;
 
-        if (!THIS->ctx->mem_acct_enable)
-                return REALLOC (ptr, size);
+    if (!gf_mem_acct_enabled())
+        return REALLOC(ptr, size);
 
-        REQUIRE(NULL != ptr);
+    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;
+    header = (struct mem_header *)(ptr - GF_MEM_HEADER_SIZE);
+    GF_ASSERT(header->magic == GF_MEM_HEADER_MAGIC);
 
-#ifdef DEBUG
-        int type = 0;
-        size_t copy_size = 0;
-
-        /* Making these changes for realloc is not straightforward. So
-         * I am simulating realloc using calloc and free
-         */
-
-        type = tmp_header.type;
-        new_ptr = __gf_calloc (1, size, type,
-                               tmp_header.mem_acct->rec[type].typestr);
-        if (new_ptr) {
-                copy_size = (size > tmp_header.size) ? tmp_header.size : size;
-                memcpy (new_ptr, ptr, copy_size);
-                __gf_free (ptr);
-        }
-
-        /* This is not quite what the man page says should happen */
-        return new_ptr;
-#endif
-
-        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;
-        }
+    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;
+        }
 #ifdef DEBUG
-                list_del (&header->acct_list);
+        list_del(&header->acct_list);
 #endif
-        }
-        UNLOCK (&mem_acct->rec[header->type].lock);
+    }
+    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);
 }
 
-#define POOL_SMALLEST   7       /* i.e. 128 */
-#define POOL_LARGEST    20      /* i.e. 1048576 */
-#define NPOOLS          (POOL_LARGEST - POOL_SMALLEST + 1)
+#if defined(GF_DISABLE_MEMPOOL)
+
+struct mem_pool *
+mem_pool_new_fn(glusterfs_ctx_t *ctx, unsigned long sizeof_type,
+                unsigned long count, char *name)
+{
+    struct mem_pool *new;
 
-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_shared   pools[NPOOLS];
-static size_t                   pool_list_size;
+    new = GF_MALLOC(sizeof(struct mem_pool), gf_common_mt_mem_pool);
+    if (!new)
+        return NULL;
 
-#if !defined(GF_DISABLE_MEMPOOL)
-#define N_COLD_LISTS    1024
-#define POOL_SWEEP_SECS 30
+    new->sizeof_type = sizeof_type;
+    return new;
+}
+
+void
+mem_pool_destroy(struct mem_pool *pool)
+{
+    GF_FREE(pool);
+}
+
+#else /* !GF_DISABLE_MEMPOOL */
 
-static unsigned long            sweep_times;
-static unsigned long            sweep_usecs;
-static unsigned long            frees_to_system;
+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 __thread per_thread_pool_list_t *thread_pool_list = NULL;
+
+#define N_COLD_LISTS 1024
+#define POOL_SWEEP_SECS 30
 
 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 (glusterfs_ctx_t *ctx, unsigned long sizeof_type,
-                 unsigned long count, char *name)
+void
+mem_pool_destroy(struct mem_pool *pool)
 {
-        unsigned int            i;
-        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;
-        }
-
-        for (i = 0; i < NPOOLS; ++i) {
-                if (sizeof_type <= AVAILABLE_SIZE(pools[i].power_of_two)) {
-                        pool = &pools[i];
-                        break;
-                }
-        }
-
-        if (!pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        new = GF_CALLOC (sizeof (struct mem_pool), 1, gf_common_mt_mem_pool);
-        if (!new)
-                return NULL;
-
-        new->ctx = ctx;
-        new->sizeof_type = sizeof_type;
-        new->count = count;
-        new->name = name;
-        new->pool = pool;
-        GF_ATOMIC_INIT (new->active, 0);
-        INIT_LIST_HEAD (&new->owner);
-
-        LOCK (&ctx->lock);
-        {
-                list_add (&new->owner, &ctx->mempool_list);
-        }
-        UNLOCK (&ctx->lock);
+    if (!pool)
+        return;
 
-        return new;
+    /* 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;
-
-        if (!mem_pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        ptr = mem_get(mem_pool);
-        if (ptr) {
-#if defined(GF_DISABLE_MEMPOOL)
-                memset (ptr, 0, mem_pool->sizeof_type);
-#else
-                memset (ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
+    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];
+
+    new = GF_MALLOC(sizeof(struct mem_pool), gf_common_mt_mem_pool);
+    if (!new)
+        return NULL;
+
+    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);
 
-        return ptr;
-}
+    LOCK(&ctx->lock);
+    {
+        list_add(&new->owner, &ctx->mempool_list);
+    }
+    UNLOCK(&ctx->lock);
 
+    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
         }
+    }
 
-        GF_ATOMIC_INC (pt_pool->parent->allocs_stdc);
-        return malloc (1 << pt_pool->parent->power_of_two);
+    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;
+    }
+
+    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_MALLOC (mem_pool->sizeof_type, 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;
-        }
-
-        pool_list = mem_get_pool_list ();
-        if (!pool_list || pool_list->poison) {
-                return NULL;
-        }
+        memset(ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
+#endif
+    }
 
-        (void) pthread_spin_lock (&pool_list->lock);
-        pt_pool = &pool_list->pools[mem_pool->pool->power_of_two-POOL_SMALLEST];
-        retval = mem_get_from_pool (pt_pool);
+    return ptr;
+}
 
-        if (!retval) {
-                (void) pthread_spin_unlock (&pool_list->lock);
-                return NULL;
-        }
+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;
+    }
 
-        retval->magic = GF_MEM_HEADER_MAGIC;
-        retval->pool = mem_pool;
-        retval->pool_list = pool_list;
-        retval->power_of_two = mem_pool->pool->power_of_two;
-        (void) pthread_spin_unlock (&pool_list->lock);
+#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;
+    }
 
-        GF_ATOMIC_INC (mem_pool->active);
+    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;
+    }
 
-        GF_ATOMIC_DEC (hdr->pool->active);
+    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;
-        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);
-#endif /* GF_DISABLE_MEMPOOL */
-}
+    if (!hdr->pool_list) {
+        gf_msg_callingfn("mem-pool", GF_LOG_CRITICAL, EINVAL,
+                         LG_MSG_INVALID_ARG,
+                         "invalid argument hdr->pool_list NULL");
+        return;
+    }
 
-void
-mem_pool_destroy (struct mem_pool *pool)
-{
-        if (!pool)
-                return;
+    pool_list = hdr->pool_list;
+    pt_pool = &pool_list->pools[hdr->power_of_two - POOL_SMALLEST];
 
-        /* remove this pool from the owner (glusterfs_ctx_t) */
-        LOCK (&pool->ctx->lock);
-        {
-                list_del (&pool->owner);
-        }
-        UNLOCK (&pool->ctx->lock);
+    if (hdr->pool)
+        GF_ATOMIC_DEC(hdr->pool->active);
 
-        /* free this pool, but keep the mem_pool_shared */
-        GF_FREE (pool);
+    hdr->magic = GF_MEM_INVALID_MAGIC;
 
-        /*
-         * 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)pthread_spin_lock(&pool_list->lock);
+    if (!pool_list->poison) {
+        hdr->next = pt_pool->hot_list;
+        pt_pool->hot_list = hdr;
+        (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 */
 }
diff --git a/libglusterfs/src/mem-pool.h b/libglusterfs/src/mem-pool.h
deleted file mode 100644
index a2a907a2344..00000000000
--- a/libglusterfs/src/mem-pool.h
+++ /dev/null
@@ -1,304 +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 "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
-
-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;
-#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, ...);
-
-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_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;
-}
-
-/* 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;
-        gf_atomic_t             active; /* current allocations */
-
-        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;
-
-#define AVAILABLE_SIZE(p2)      ((1 << (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 {
-        /*
-         * 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;
-
-/* 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_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 (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/mem-types.h b/libglusterfs/src/mem-types.h
deleted file mode 100644
index 85c06e9cbe5..00000000000
--- a/libglusterfs/src/mem-types.h
+++ /dev/null
@@ -1,182 +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,
-        gf_common_mt_mem_pool,
-        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_server_cmdline_t,
-        gf_common_mt_end
-};
-#endif
diff --git a/libglusterfs/src/monitoring.c b/libglusterfs/src/monitoring.c
index 10b0a817e40..fbb68dc8622 100644
--- a/libglusterfs/src/monitoring.c
+++ b/libglusterfs/src/monitoring.c
@@ -8,263 +8,275 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "monitoring.h"
-#include "xlator.h"
-#include "syscall.h"
+#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, %"GF_PRI_SIZET", %u, %"GF_PRI_SIZET", %u,"
-                         " %u\n", mem_rec->typestr, mem_rec->size,
-                         mem_rec->num_allocs, mem_rec->max_size,
-                         mem_rec->max_num_allocs, mem_rec->total_allocs);
-        }
+    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)
+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");
+    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 */
+    /* 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)
+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 %lu\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 %lu\n", xl->name, count);
-
-        count = GF_ATOMIC_GET (xl->stats.interval.count);
-        dprintf (fd, "%s.interval.fop-count %lu\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 %lu\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 %lu\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 %lu\n",
-                                 xl->name, gf_fop_list[index], cbk);
-                }
-                if (xl->stats.interval.latencies[index].count != 0.0) {
-                        dprintf (fd, "%s.interval.%s.latency %lf\n",
-                                 xl->name, gf_fop_list[index],
-                                 (xl->stats.interval.latencies[index].total /
-                                  xl->stats.interval.latencies[index].count));
-                        dprintf (fd, "%s.interval.%s.max %lf\n",
-                                 xl->name, gf_fop_list[index],
-                                 xl->stats.interval.latencies[index].max);
-                        dprintf (fd, "%s.interval.%s.min %lf\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);
+    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);
         }
-        memset (xl->stats.interval.latencies, 0,
-                sizeof (xl->stats.interval.latencies));
+        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)
+dump_call_stack_details(glusterfs_ctx_t *ctx, int fd)
 {
-        dprintf (fd, "total.stack.count %lu\n",
-                 GF_ATOMIC_GET (ctx->pool->total_count));
-        dprintf (fd, "total.stack.in-flight %lu\n",
-                 ctx->pool->cnt);
+    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)
+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 %lu\n",
-                 GF_ATOMIC_GET (ctx->stats.max_dict_pairs));
-        dprintf (fd, "total.dict.pairs-used %lu\n", total_pairs);
-        dprintf (fd, "total.dict.used %lu\n", total_dicts);
-        dprintf (fd, "total.dict.average-pairs %lu\n",
-                            (total_pairs / total_dicts));
+    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)
+dump_inode_stats(glusterfs_ctx_t *ctx, int fd)
 {
 }
 
 static void
-dump_global_metrics (glusterfs_ctx_t *ctx, int fd)
+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");
+    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)
+dump_xl_metrics(glusterfs_ctx_t *ctx, int fd)
 {
-        xlator_t *xl;
+    xlator_t *xl;
 
-        xl = ctx->active->top;
+    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;
-        }
+    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;
+    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);
-        }
+        dump_latency_and_count(xl, fd);
+        dump_mem_acct_details(xl, fd);
+        if (xl->dump_metrics)
+            xl->dump_metrics(xl, fd);
+    }
 
-        return;
+    return;
 }
 
 char *
-gf_monitor_metrics (glusterfs_ctx_t *ctx)
+gf_monitor_metrics(glusterfs_ctx_t *ctx)
 {
-        int ret = -1;
-        int fd = 0;
-        char *filepath, *dumppath;
-
-        dumppath = ctx->config.metrics_dumppath;
-        if (dumppath == NULL) {
-                dumppath = GLUSTER_METRICS_DIR;
-        }
-
-        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;
+    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 1aa27341624..00000000000
--- a/libglusterfs/src/options.h
+++ /dev/null
@@ -1,342 +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;
-
-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;
-
-        /* The level at which the option is classified
-         */
-        opt_level_t             level;
-} 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 (this->name, GF_LOG_INFO, 0, 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 06fc7ee35c8..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,391 +79,376 @@ err:
  */
 
 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)
+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_ctx (ctx, 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 949b88a4380..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 (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.c b/libglusterfs/src/refcount.c
index 714bb9afef6..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 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 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 cbded2b3f46..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,10 +26,10 @@
  * 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 shrunk (deallocated) if usage/total count
@@ -37,373 +37,372 @@
  * 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 8ee5271533e..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 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.c b/libglusterfs/src/run.c
index c501bab9685..58f95a7e610 100644
--- a/libglusterfs/src/run.c
+++ b/libglusterfs/src/run.c
@@ -23,7 +23,7 @@
 #include <assert.h>
 #include <signal.h>
 #include <sys/wait.h>
-#include "syscall.h"
+#include "glusterfs/syscall.h"
 
 /*
  * Following defines are available for helping development:
@@ -42,8 +42,9 @@
  *
  * $ 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);
+#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)
@@ -54,513 +55,516 @@ int close_fds_except (int *fdv, size_t count);
 #define gf_strdup(s) strdup(s)
 #define gf_vasprintf(p, f, va) vasprintf(p, f, va)
 #define gf_loglevel_t int
-#define gf_msg_callingfn(dom, level, errnum, msgid, 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)
+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);
+    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;
+            }
         }
-        return 0;
+        if (should_close)
+            sys_close(i);
+    }
+    return 0;
 }
 #endif
 #ifdef __linux__
 #define GF_LINUX_HOST_OS
 #endif
 #else /* ! RUN_STANDALONE || RUN_DO_DEMO */
-#include "glusterfs.h"
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 #endif
 
-#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 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;
-                        }
+            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_DEMO
 static void
-TBANNER (const char *txt)
+TBANNER(const char *txt)
 {
-        printf("######\n### demoing %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;
-        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;
+    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 13107e4e3bc..1531f0da43f 100644
--- a/libglusterfs/src/stack.c
+++ b/libglusterfs/src/stack.c
@@ -8,437 +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 (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++;
-        }
-        UNLOCK (&pool->lock);
-        GF_ATOMIC_INC (pool->total_count);
-
-        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
-call_stack_set_groups (call_stack_t *stack, int ngrps, gid_t **groupbuf_p)
+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;
+    /* 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;
 }
 
 void
-gf_proc_dump_call_frame (call_frame_t *call_frame, const char *key_buf,...)
+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;
 
-        char prefix[GF_DUMP_MAX_BUF_LEN];
-        va_list ap;
-        call_frame_t my_frame;
-        int  ret = -1;
-        char timestr[256] = {0,};
+    GF_ASSERT(key_buf);
 
-        if (!call_frame)
-                return;
+    va_start(ap, key_buf);
+    vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
+    va_end(ap);
 
-        GF_ASSERT (key_buf);
+    ret = TRY_LOCK(&call_frame->lock);
+    if (ret)
+        goto out;
 
-        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);
+    memcpy(&my_frame, call_frame, sizeof(my_frame));
+    UNLOCK(&call_frame->lock);
 
-        ret = TRY_LOCK(&call_frame->lock);
-        if (ret)
-                goto out;
-
-        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);
-                snprintf (timestr + strlen (timestr),
-                          sizeof (timestr) - strlen (timestr),
-                          ".%"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);
-        }
-
-        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.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.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);
-
-        ret = 0;
+    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);
+    }
+
+    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.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.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);
+
+    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);
-
-        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);
-        snprintf (timestr + strlen (timestr),
-                  sizeof (timestr) - strlen (timestr),
-                  ".%"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", "%Ld", call_stack->unique);
-        gf_proc_dump_write("lk-owner", "%s", lkowner_utoa (&call_stack->lk_owner));
-        gf_proc_dump_write("ctime", "%lld.%"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++;
-        }
+    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_false;
-
-        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,};
-        char            msg[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;
 
-        ret = TRY_LOCK (&call_frame->lock);
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_set_int32(dict, key, tmp_frame.complete);
+    if (ret)
+        return;
+
+    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;
+    }
 
-        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;
+    }
 
-        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;
+    }
 
-        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.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;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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.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));
-        }
+            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);
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->uid);
-        if (ret)
-                return;
-
-        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;
 
-        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;
 
-        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;
 
-        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;
 
-        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");
 
-        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) {
-                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;
+
+    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++;
-        }
+    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 212a649d42e..00000000000
--- a/libglusterfs/src/stack.h
+++ /dev/null
@@ -1,557 +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 "lkowner.h"
-#include "client_t.h"
-#include "libglusterfs-messages.h"
-#include "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,
-                             ...);
-
-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;
-void gf_update_latency (call_frame_t *frame);
-
-
-static inline void
-FRAME_DESTROY (call_frame_t *frame)
-{
-        void *local = NULL;
-
-        if (frame->root->ctx->measure_latency)
-                gf_update_latency (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;                         \
-                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);                                                   \
-
-
-/* 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 {
-		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_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/statedump.c b/libglusterfs/src/statedump.c
index 741b2b97555..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,1031 +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;
-
-        fp = fopen (dump_options_file, "r");
-        if (!fp)
-                goto out;
+    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;
+        }
+
+        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);
-
-        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 = 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);
-
-        offset = strlen (buf);
-        snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "\n");
-        return sys_write (gf_dump_fd, buf, strlen (buf));
+    len += snprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, "\n");
+    return sys_write(gf_dump_fd, buf, len);
 }
 
+static int
+gf_proc_dump_write_strfd(char *key, char *value, va_list ap)
+{
+    int ret = 0;
+
+    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)
+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);
-        }
+    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;
-
-        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].size)
-                        continue;
-
-                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);
-        }
+    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].size)
+            continue;
+
+        gf_proc_dump_add_section("%s.%s - usage-type %d", xl->type, xl->name,
+                                 i);
+
+        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;
+}
 
 /* Currently this dumps only mallinfo. More can be built on here */
 void
-gf_proc_dump_mem_info ()
+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);
+#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;
-
-        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.ordblks", info.ordblks);
-        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.hblkhd", info.hblkhd);
-        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.uordblks", info.uordblks);
-        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
+    if (!dict)
+        return;
+#ifdef HAVE_MALLINFO
+    struct mallinfo info;
+    int ret = -1;
+
+    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.ordblks", info.ordblks);
+    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.hblkhd", info.hblkhd);
+    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.uordblks", info.uordblks);
+    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
+    return;
 }
 
 void
-gf_proc_dump_mempool_info (glusterfs_ctx_t *ctx)
+gf_proc_dump_mempool_info(glusterfs_ctx_t *ctx)
 {
-        struct mem_pool *pool = NULL;
-
-        gf_proc_dump_add_section ("mempool");
-
-#if defined(OLD_MEM_POOLS)
-        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);
-        }
+#ifdef GF_DISABLE_MEMPOOL
+    gf_proc_dump_write("built with --disable-mempool", " so no memory pools");
 #else
-        LOCK (&ctx->lock);
+    struct mem_pool *pool = NULL;
+
+    gf_proc_dump_add_section("mempool");
+
+    LOCK(&ctx->lock);
+    {
+        list_for_each_entry(pool, &ctx->mempool_list, owner)
         {
-                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 ("active-count", "%"GF_PRI_ATOMIC, active);
-                        gf_proc_dump_write ("sizeof-type", "%d", pool->sizeof_type);
-                        gf_proc_dump_write ("padded-sizeof", "%lu", 1 << pool->pool->power_of_two);
-                        gf_proc_dump_write ("size", "%lu", (1 << pool->pool->power_of_two) * active);
-                        gf_proc_dump_write ("shared-pool", "%p", pool->pool);
-                }
+            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);
         }
-        UNLOCK (&ctx->lock);
-
-        /* TODO: details of (struct mem_pool_shared) 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)
+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) {
-                snprintf (key, sizeof (key), "pool%d.name", count);
-                ret = dict_set_str (dict, key, pool->name);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.hotcount", count);
-                ret = dict_set_int32 (dict, key, pool->hot_count);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.coldcount", count);
-                ret = dict_set_int32 (dict, key, pool->cold_count);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.paddedsizeof", count);
-                ret = dict_set_uint64 (dict, key, pool->padded_sizeof_type);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.alloccount", count);
-                ret = dict_set_uint64 (dict, key, pool->alloc_count);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.max_alloc", count);
-                ret = dict_set_int32 (dict, key, pool->max_alloc);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.max-stdalloc", count);
-                ret = dict_set_int32 (dict, key, pool->max_stdalloc);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.pool-misses", count);
-                ret = dict_set_uint64 (dict, key, pool->pool_misses);
-                if (ret)
-                        return;
-                count++;
+#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));
 }
 
 static void
-gf_proc_dump_single_xlator_info (xlator_t *trav)
+gf_proc_dump_single_xlator_info(xlator_t *trav)
 {
-        glusterfs_ctx_t *ctx = trav->ctx;
-        char             itable_key[1024] = {0,};
+    glusterfs_ctx_t *ctx = trav->ctx;
+    char itable_key[1024] = {
+        0,
+    };
 
+    if (trav->cleanup_starting)
+        return;
 
-        if (trav->cleanup_starting)
-                return;
-
-        if (ctx->measure_latency)
-                gf_proc_dump_latency_info (trav);
+    if (ctx->measure_latency)
+        gf_proc_dump_xl_latency_info(trav);
 
-        gf_proc_dump_xlator_mem_info(trav);
+    gf_proc_dump_xlator_mem_info(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->itable)) {
+        snprintf(itable_key, sizeof(itable_key), "%d.%s.itable", ctx->graph_id,
+                 trav->name);
+    }
 
-        if (!trav->dumpops) {
-                return;
-        }
+    if (!trav->dumpops) {
+        return;
+    }
 
-        if (trav->dumpops->priv &&
-            GF_PROC_DUMP_IS_XL_OPTION_ENABLED (priv))
-                trav->dumpops->priv (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->dumpops->inode))
-                trav->dumpops->inode (trav);
-        if (trav->dumpops->fd &&
-            GF_PROC_DUMP_IS_XL_OPTION_ENABLED (fd))
-                trav->dumpops->fd (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->history &&
-            GF_PROC_DUMP_IS_XL_OPTION_ENABLED (history))
-                trav->dumpops->history (trav);
+    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)
+gf_proc_dump_per_xlator_info(xlator_t *top)
 {
-        xlator_t        *trav = top;
+    xlator_t *trav = top;
 
-        while (trav && !trav->cleanup_starting) {
-                gf_proc_dump_single_xlator_info (trav);
-                trav = trav->next;
-        }
+    while (trav && !trav->cleanup_starting) {
+        gf_proc_dump_single_xlator_info(trav);
+        trav = trav->next;
+    }
 }
 
-
-
 void
-gf_proc_dump_xlator_info (xlator_t *top, gf_boolean_t brick_mux)
+gf_proc_dump_xlator_info(xlator_t *top, gf_boolean_t brick_mux)
 {
-        xlator_t        *trav = NULL;
-        xlator_list_t   **trav_p        = NULL;
-
-        if (!top)
-                return;
-
-        trav = top;
-        gf_proc_dump_per_xlator_info (trav);
-
-        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;
-                }
-        }
+    xlator_t *trav = NULL;
+    xlator_list_t **trav_p = NULL;
 
+    if (!top)
         return;
+
+    trav = top;
+    gf_proc_dump_per_xlator_info(trav);
+
+    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;
 }
 
 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 ()
+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);
+    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_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_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_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_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 ()
+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 ());
+    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");
 
-                fp = fopen (dump_option_file, "r");
-
-                if (!fp) {
-                        //ENOENT, return success
-                        (void) gf_proc_dump_enable_all_options ();
-                        return 0;
-                }
+        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);
+    (void)gf_proc_dump_disable_all_options();
 
-        ret = fscanf (fp, "%s", buf);
+    // swallow the errors if setting statedump file path is failed.
+    (void)gf_proc_dump_set_path(dump_option_file);
 
-        while (ret != EOF) {
-                key = strtok_r (buf, "=", &saveptr);
-                if (!key) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
+    ret = fscanf(fp, "%255s", buf);
 
-                value = strtok_r (NULL, "=", &saveptr);
+    while (ret != EOF) {
+        key = strtok_r(buf, "=", &saveptr);
+        if (!key) {
+            ret = fscanf(fp, "%255s", buf);
+            continue;
+        }
 
-                if (!value) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
+        value = strtok_r(NULL, "=", &saveptr);
 
-                gf_proc_dump_parse_set_option (key, value);
+        if (!value) {
+            ret = fscanf(fp, "%255s", buf);
+            continue;
         }
 
-        if (is_gf_proc_dump_all_disabled ())
-                (void) gf_proc_dump_enable_default_options ();
+        gf_proc_dump_parse_set_option(key, value);
+    }
 
-        if (fp)
-                fclose (fp);
+    if (is_gf_proc_dump_all_disabled())
+        (void)gf_proc_dump_enable_default_options();
 
-        return 0;
+    if (fp)
+        fclose(fp);
+
+    return 0;
 }
 
 void
-gf_proc_dump_info (int signum, glusterfs_ctx_t *ctx)
+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[256]            = {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;
-
-        gf_proc_dump_lock ();
-
-        if (!ctx)
-                goto out;
-
-        if (ctx) {
-                top = ctx->active->first;
-                for (trav_p = &top->children; *trav_p;
-                                     trav_p = &(*trav_p)->next) {
-                        brick_count++;
-                }
-
-                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
-                strncpy (brick_name, "glusterdump", sizeof (brick_name));
-
-        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) time (NULL));
-        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 (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-        }
-
-        snprintf (sign_string, sizeof (sign_string), "DUMP-START-TIME: %s\n",
-                  timestr);
-
-        //swallow the errors of write for start and end marker
-        ret = sys_write (gf_dump_fd, sign_string, strlen (sign_string));
-
-        memset (timestr, 0, sizeof (timestr));
-
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (mem)) {
-                gf_proc_dump_mem_info ();
-                gf_proc_dump_mempool_info (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++;
         }
 
-        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 (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-        }
-
-        snprintf (sign_string, sizeof (sign_string), "\nDUMP-END-TIME: %s",
-                  timestr);
-        ret = sys_write (gf_dump_fd, sign_string, strlen (sign_string));
-
-        if (gf_dump_fd != -1)
-                gf_proc_dump_close ();
-        sys_rename (tmp_dump_name, path);
+        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:
-        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 92246e1e37e..00000000000
--- a/libglusterfs/src/statedump.h
+++ /dev/null
@@ -1,111 +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, ...)
-{
-        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,...);
-
-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 d22027b32c7..5c316b9291a 100644
--- a/libglusterfs/src/store.c
+++ b/libglusterfs/src/store.c
@@ -11,730 +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;
-        }
+    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) {
-                int duped_fd = dup(handle->fd);
-
-                if (duped_fd >= 0)
-                        handle->read = fdopen (duped_fd, "r");
-                if (!handle->read) {
-                        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);
-        }
-        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 1ccda55e4c5..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,402 +157,394 @@ 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);
 
-                gf_dirent_free (&entries);
+            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)
-                        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;
+            }
 
-                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;
+            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;
         }
+    }
 
 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);
 
-        if (mut_init)
-                pthread_mutex_destroy (&mut);
-        if (cond_init)
-                pthread_cond_destroy (&cond);
-        return ret|retval;
+    pthread_mutex_lock(&mut);
+    {
+        while (jobs_running)
+            pthread_cond_wait(&cond, &mut);
+    }
+    pthread_mutex_unlock(&mut);
+
+    gf_dirent_free(&q);
+    gf_dirent_free(&entries);
+
+    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;
 }
 
 /**
@@ -565,109 +558,112 @@ out:
  **/
 
 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)
+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);
-
-        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;
-                }
+    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_gfid_to_path (inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
-                     char **path_p)
+syncop_gfid_to_path(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                    char **path_p)
 {
-        return syncop_gfid_to_path_hard (itable, subvol, gfid, NULL, path_p,
-                                         _gf_false);
+    return syncop_gfid_to_path_hard(itable, subvol, gfid, NULL, path_p,
+                                    _gf_false);
 }
 
 int
-syncop_inode_find (xlator_t *this, xlator_t *subvol,
-                   uuid_t gfid, inode_t **inode,
-                   dict_t *xdata, dict_t **rsp_dict)
+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;
-        }
+    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 97b35046780..00000000000
--- a/libglusterfs/src/syncop-utils.h
+++ /dev/null
@@ -1,55 +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);
-
-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/syncop.c b/libglusterfs/src/syncop.c
index 8323dd71a10..df20cec559f 100644
--- a/libglusterfs/src/syncop.c
+++ b/libglusterfs/src/syncop.c
@@ -8,2762 +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;
-
-        VALIDATE_OR_GOTO (env, err);
-        VALIDATE_OR_GOTO (fn, err);
+    struct synctask *newtask = NULL;
+    xlator_t *this = THIS;
+    int destroymode = 0;
 
-        /* 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;
-
-        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);
-                if (!newtask->opframe)
-                        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;
-        }
+    VALIDATE_OR_GOTO(env, err);
+    VALIDATE_OR_GOTO(fn, 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;
-        }
+    /* 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);
 
-        if (!newtask->stack) {
-                goto err;
-        }
+    /* syncenv is in DESTROY mode, return from here */
+    if (destroymode)
+        return NULL;
 
-        newtask->ctx.uc_stack.ss_sp   = newtask->stack;
+    newtask = GF_CALLOC(1, sizeof(*newtask), gf_common_mt_synctask);
+    if (!newtask)
+        return NULL;
 
-        makecontext (&newtask->ctx, (void (*)(void)) synctask_wrap, 0);
+    newtask->frame = frame;
+    if (!frame) {
+        newtask->opframe = create_frame(this, this->ctx->pool);
+        if (!newtask->opframe)
+            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),
-                                  "sproc%03hx", (env->procs & 0x3ff));
-                        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;
 
+    task = synctask_get();
 
-        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);
+    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;
+
+    errno = 0;
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		ret = __synclock_lock (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);
+
+    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;
+    }
+
+    ret = pthread_cond_init(&cond->pcond, NULL);
+    if (ret != 0) {
+        pthread_mutex_destroy(&cond->pmutex);
+    }
 
-	return ret;
+    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)
 {
-	int ret = 0;
+    return synccond_timedwait(cond, lock, NULL);
+}
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		ret = __synclock_unlock (lock);
-	}
-	pthread_mutex_unlock (&lock->guard);
+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);
 
-	return ret;
+        synctask_wake(task);
+    } else {
+        pthread_cond_signal(&cond->pcond);
+
+        pthread_mutex_unlock(&cond->pmutex);
+    }
+}
+
+void
+synccond_broadcast(synccond_t *cond)
+{
+    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_unlock(&cond->pmutex);
+
+    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)
 {
-        int ret = 0;
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = 0;
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	ret = pthread_cond_init (&barrier->cond, 0);
-        if (ret) {
-                errno = ret;
-                return -1;
-        }
-	barrier->count = 0;
-        barrier->waitfor = 0;
-	INIT_LIST_HEAD (&barrier->waitq);
-
-	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;
-}
+    ret = pthread_cond_init(&barrier->cond, 0);
+    if (ret) {
+        errno = ret;
+        return -1;
+    }
+    barrier->count = 0;
+    barrier->waitfor = 0;
+    INIT_LIST_HEAD(&barrier->waitq);
 
+    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)
 {
-        int ret = 0;
-        int ret1 = 0;
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = 0;
+    int ret1 = 0;
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        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;
+    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, };
-
-        SYNCOP (subvol, (&args), syncop_readdir_cbk, subvol->fops->readdir,
-                fd, size, off, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (entries)
-                list_splice_init (&args.entries.list, &entries->list);
-        else
-                gf_dirent_free (&args.entries);
+    SYNCOP(subvol, (&args), syncop_readdir_cbk, subvol->fops->readdir, fd, size,
+           off, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (entries)
+        list_splice_init(&args.entries.list, &entries->list);
+    else
+        gf_dirent_free(&args.entries);
 
-        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, };
-
-        SYNCOP (subvol, (&args), syncop_open_cbk, subvol->fops->open,
-                loc, flags, fd, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    SYNCOP(subvol, (&args), syncop_open_cbk, subvol->fops->open, loc, flags, fd,
+           xdata_in);
 
-        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->iatt1 = *stbuf;
-        }
+    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, struct iatt *iatt,
-              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 (iatt)
-                *iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                goto out;
+    if (args.op_ret < 0)
+        goto out;
 
-        if (vector)
-                *vector = args.vector;
-        else
-                GF_FREE (args.vector);
+    if (vector)
+        *vector = args.vector;
+    else
+        GF_FREE(args.vector);
 
-        if (count)
-                *count = args.count;
+    if (count)
+        *count = args.count;
 
-        /* Do we need a 'ref' here? */
-        if (iobref)
-                *iobref = args.iobref;
-        else if (args.iobref)
-                iobref_unref (args.iobref);
+    /* 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;
+    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);
 
-        if (op_ret >= 0) {
-                args->iatt1 = *prebuf;
-                args->iatt2 = *postbuf;
-        }
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    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, struct iatt *preiatt, struct iatt *postiatt,
-               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 (preiatt)
-                *preiatt = args.iatt1;
-        if (postiatt)
-                *postiatt = args.iatt2;
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = 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_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;
 }
 
 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)
+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);
 
-        if (buf)
-                args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 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)
+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_put_cbk, subvol->fops->put,
-                loc, mode, umask, flags, (struct iovec *) vector, count,
-                offset, iobref, xattr, 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 (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_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)
+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_unlink (xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
-               dict_t **xdata_out)
+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_unlink_cbk, subvol->fops->unlink, loc,
-                0, 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_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_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;
+    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,
-              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, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_rmdir_cbk, subvol->fops->rmdir, loc,
-                flags, xdata_in);
+    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_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_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);
 
-        if (buf)
-                args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __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_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_link_cbk, subvol->fops->link,
-                oldloc, newloc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_link_cbk, subvol->fops->link, oldloc, newloc,
+           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 (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;
 }
 
-
 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_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_rename (xlator_t *subvol, loc_t *oldloc, loc_t *newloc,
-               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_rename_cbk, subvol->fops->rename,
-                oldloc, newloc, 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;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    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_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 = 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 = *prebuf;
-                args->iatt2 = *postbuf;
-        }
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 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)
+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 = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_ftruncate_cbk, subvol->fops->ftruncate,
-                fd, offset, xdata_in);
+    SYNCOP(subvol, (&args), syncop_ftruncate_cbk, subvol->fops->ftruncate, fd,
+           offset, xdata_in);
 
-        if (preiatt)
-                *preiatt = args.iatt1;
-        if (postiatt)
-                *postiatt = args.iatt2;
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = 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_truncate (xlator_t *subvol, loc_t *loc, off_t offset, 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_ftruncate_cbk, subvol->fops->truncate,
-                loc, offset, 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 (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_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_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);
 
-        if (op_ret >= 0) {
-                args->iatt1 = *prebuf;
-                args->iatt2 = *postbuf;
-        }
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 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)
+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, };
-
-        SYNCOP (subvol, (&args), syncop_fsync_cbk, subvol->fops->fsync,
-                fd, dataonly, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (preiatt)
-                *preiatt = args.iatt1;
-        if (postiatt)
-                *postiatt = args.iatt2;
+    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_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, 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;
-
-        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;
 
-        __wake (args);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_flush (xlator_t *subvol, fd_t *fd, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_flush(xlator_t *subvol, fd_t *fd, 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_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;
+    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_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 = 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;
+    if (op_ret == 0)
+        args->iatt1 = *stbuf;
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_fstat (xlator_t *subvol, fd_t *fd, struct iatt *stbuf, dict_t *xdata_in,
-              dict_t **xdata_out)
+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->fstat,
-                fd, 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 (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_stat (xlator_t *subvol, loc_t *loc, struct iatt *stbuf, dict_t *xdata_in,
-             dict_t **xdata_out)
+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);
+    struct syncargs args = {
+        0,
+    };
 
-        if (stbuf)
-                *stbuf = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_fstat_cbk, subvol->fops->stat, loc,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (stbuf)
+        *stbuf = 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;
 }
 
 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, };
-
-        SYNCOP (subvol, (&args), syncop_mknod_cbk, subvol->fops->mknod,
-                loc, mode, rdev, 0, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-	if (iatt)
-		*iatt = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_mknod_cbk, subvol->fops->mknod, loc, mode,
+           rdev, 0, 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_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
@@ -2782,659 +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_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		    int32_t op_ret, int32_t op_errno, 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->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args = cookie;
+    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_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)
+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, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_entrylk_cbk, subvol->fops->entrylk,
-                volume, loc, basename, cmd, type, xdata_in);
+    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 (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_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;
+    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 (dict)
-                args->dict_out = dict_ref (dict);
+    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;
+    __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 **dict_out,
-                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 (dict_out)
-                *dict_out = args.dict_out;
-        else if (args.dict_out)
-                dict_unref (args.dict_out);
+    if (dict_out)
+        *dict_out = args.dict_out;
+    else if (args.dict_out)
+        dict_unref(args.dict_out);
 
-        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;
 }
 
 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)
+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 (dict_out)
-                *dict_out = args.dict_out;
-        else if (args.dict_out)
-                dict_unref (args.dict_out);
+    if (dict_out)
+        *dict_out = args.dict_out;
+    else if (args.dict_out)
+        dict_unref(args.dict_out);
 
-        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_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;
-
-        args = cookie;
+    struct syncargs *args = NULL;
+    lock_migration_info_t *tmp = NULL;
+    lock_migration_info_t *entry = NULL;
 
-        INIT_LIST_HEAD (&args->locklist.list);
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    INIT_LIST_HEAD(&args->locklist.list);
 
-        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);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-                        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);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_getactivelk (xlator_t *subvol, loc_t *loc,
-                    lock_migration_info_t *locklist,  dict_t *xdata_in,
-                    dict_t **xdata_out)
+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);
+    struct syncargs args = {
+        0,
+    };
 
-        if (locklist)
-                list_splice_init (&args.locklist.list, &locklist->list);
-        else
-                gf_free_mig_locks (&args.locklist) ;
+    SYNCOP(subvol, (&args), syncop_getactivelk_cbk, subvol->fops->getactivelk,
+           loc, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (locklist)
+        list_splice_init(&args.locklist.list, &locklist->list);
+    else
+        gf_free_mig_locks(&args.locklist);
 
-        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_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+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 = 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);
 
+    __wake(args);
 
-        __wake (args);
-
-        return 0;
-
+    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_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);
+    struct syncargs args = {
+        0,
+    };
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    SYNCOP(subvol, (&args), syncop_setactivelk_cbk, subvol->fops->setactivelk,
+           loc, locklist, xdata_in);
 
-        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_icreate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+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;
-        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_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)
+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;
+    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);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_icreate (xlator_t *subvol, loc_t *loc, mode_t mode, dict_t *xdata)
+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_icreate_cbk, subvol->fops->icreate,
-                loc, mode, xdata);
+    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)
-                xdata = 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;
+    }
 
-        errno = args.op_errno;
-        return args.op_ret;
+    if (xdata_out) {
+        *xdata_out = args.xdata;
+    } else if (args.xdata) {
+        dict_unref(args.xdata);
+    }
+
+    errno = args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_namelink (xlator_t *subvol, loc_t *loc, dict_t *xdata)
+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 = {0, };
+    struct syncargs *args = NULL;
 
-        SYNCOP (subvol, (&args), syncop_namelink_cbk, subvol->fops->namelink,
-                loc, xdata);
+    args = cookie;
 
-        if (xdata)
-                xdata = 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);
 
-        errno = args.op_errno;
-        return args.op_ret;
+    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 3000d2e74c9..00000000000
--- a/libglusterfs/src/syncop.h
+++ /dev/null
@@ -1,594 +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 {
-        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;
-        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;
-        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);				\
-	} 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 = task->opframe;                          \
-                else                                                    \
-                        frame = syncop_create_frame (THIS);		\
-                                                                        \
-                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);                                          \
-                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, 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_namelink (xlator_t *subvol, loc_t *loc, 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);
-
-#endif /* _SYNCOP_H */
diff --git a/libglusterfs/src/syscall.c b/libglusterfs/src/syscall.c
index 6a17d1ec6ca..04400f98b6c 100644
--- a/libglusterfs/src/syscall.c
+++ b/libglusterfs/src/syscall.c
@@ -8,789 +8,869 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "syscall.h"
-#include "compat.h"
-#include "mem-pool.h"
-#include "libglusterfs-messages.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)
-
+    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_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_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;                                                      \
-})
+#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 FS_RET_CHECK0(lstat (path, buf), errno);
+    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 FS_RET_CHECK0(stat (path, buf), errno);
+    return FS_RET_CHECK0(stat(path, buf), errno);
 }
 
-
 int
-sys_fstat (int fd, struct stat *buf)
+sys_fstat(int fd, struct stat *buf)
 {
-        return FS_RET_CHECK0(fstat (fd, buf), errno);
+    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 FS_RET_CHECK0(lstat(pathname, buf), errno);
-        else
-                return FS_RET_CHECK0(stat(pathname, buf), errno);
+    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 FS_RET_CHECK0(fstatat (dirfd, pathname, buf, flags), errno);
+    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 FS_RET_CHECK(fd, errno);
+    return FS_RET_CHECK(fd, errno);
 }
 
-
 int
 sys_open(const char *pathname, int flags, int mode)
 {
-        return FS_RET_CHECK(sys_openat(AT_FDCWD, pathname, flags, mode), errno);
+    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 FS_RET_CHECK0(mkdir(pathname, mode), errno);
+    if (fchdir(dirfd) < 0)
+        return -1;
+    return FS_RET_CHECK0(mkdir(pathname, mode), errno);
 #else
-        return FS_RET_CHECK0(mkdirat (dirfd, pathname, mode), errno);
+    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 FS_RET_CHECK(readlink (path, buf, bufsiz), errno);
+    return FS_RET_CHECK(readlink(path, buf, bufsiz), errno);
 }
 
-
 int
-sys_closedir (DIR *dir)
+sys_closedir(DIR *dir)
 {
-        return FS_RET_CHECK0(closedir (dir), errno);
+    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 FS_RET_CHECK0(mknod (pathname, mode, dev), errno);
+    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 FS_RET_CHECK0(mkdir (pathname, mode), errno);
+    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 FS_RET_CHECK0(solaris_unlink (pathname), errno);
+    return FS_RET_CHECK0(solaris_unlink(pathname), errno);
 #endif
-        return FS_RET_CHECK0(unlink (pathname), errno);
+    return FS_RET_CHECK0(unlink(pathname), errno);
 }
 
-
 int
-sys_rmdir (const char *pathname)
+sys_unlinkat(int dfd, const char *pathname)
 {
-        return FS_RET_CHECK0(rmdir (pathname), errno);
+#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 FS_RET_CHECK0(symlink (oldpath, newpath), errno);
+    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 FS_RET_CHECK0(solaris_rename (oldpath, newpath), errno);
+    return FS_RET_CHECK0(solaris_rename(oldpath, newpath), errno);
 #endif
-        return FS_RET_CHECK0(rename (oldpath, newpath), errno);
+    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 FS_RET_CHECK0(linkat (AT_FDCWD, oldpath, AT_FDCWD, newpath, 0),
-                             errno);
+    /*
+     * 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 FS_RET_CHECK0(link (oldpath, newpath), errno);
+    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 FS_RET_CHECK0(chmod (path, mode), errno);
+    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 FS_RET_CHECK0(fchmod (fd, mode), errno);
+    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 FS_RET_CHECK0(chown (path, owner, group), errno);
+    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 FS_RET_CHECK0(fchown (fd, owner, group), errno);
+    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 FS_RET_CHECK0(lchown (path, owner, group), errno);
+    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 FS_RET_CHECK0(truncate (path, length), errno);
+    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 FS_RET_CHECK0(ftruncate (fd, length), errno);
+    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 FS_RET_CHECK0(utimes (filename, times), errno);
+    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 FS_RET_CHECK0(utimensat (dirfd, filename, times, flags), errno);
+    return FS_RET_CHECK0(utimensat(dirfd, filename, times, flags), errno);
 }
 #endif
 
-
 int
-sys_futimes (int fd, const struct timeval times[2])
+sys_futimes(int fd, const struct timeval times[2])
 {
-        return futimes (fd, times);
+    return futimes(fd, times);
 }
 
-
 int
-sys_creat (const char *pathname, mode_t mode)
+sys_creat(const char *pathname, mode_t mode)
 {
-        return FS_RET_CHECK(sys_open(pathname, O_CREAT | O_TRUNC | O_WRONLY,
-                                     mode), errno);
+    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 FS_RET_CHECK(readv (fd, iov, iovcnt), errno);
+    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 FS_RET_CHECK(writev (fd, iov, iovcnt), errno);
+    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 FS_RET_CHECK(read (fd, buf, count), errno);
+    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 FS_RET_CHECK(write (fd, buf, count), errno);
+    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 FS_RET_CHECK(preadv (fd, iov, iovcnt, offset), errno);
+    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 FS_RET_CHECK(pwritev (fd, iov, iovcnt, offset), errno);
+    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 FS_RET_CHECK(pread (fd, buf, count, offset), errno);
+    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 FS_RET_CHECK(pwrite (fd, buf, count, offset), errno);
+    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 FS_RET_CHECK(lseek (fd, offset, whence), errno);
+    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 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;
-        }
+    /* 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 FS_RET_CHECK0(ret, errno);
+    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 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;
-        }
+    /* 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 FS_RET_CHECK0(ret, errno);
+    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 FS_RET_CHECK0(ret, errno);
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_fsync (int fd)
+sys_fsync(int fd)
 {
-        return FS_RET_CHECK0(fsync (fd), errno);
+    return FS_RET_CHECK0(fsync(fd), errno);
 }
 
-
 int
-sys_fdatasync (int fd)
+sys_fdatasync(int fd)
 {
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(fcntl (fd, F_FULLFSYNC), errno);
+    return FS_RET_CHECK0(fcntl(fd, F_FULLFSYNC), errno);
 #elif __FreeBSD__
-	return FS_RET_CHECK0(fsync (fd), errno);
+    return FS_RET_CHECK0(fsync(fd), errno);
 #else
-        return FS_RET_CHECK0(fdatasync (fd), errno);
+    return FS_RET_CHECK0(fdatasync(fd), errno);
 #endif
 }
 
 void
 gf_add_prefix(const char *ns, const char *key, char **newkey)
 {
-        /* 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);
-        }
+    /* 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);
-                if (!*newkey)
-                        return;
-                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 FS_RET_CHECK0(lsetxattr (path, name, value, size, flags), errno);
+    return FS_RET_CHECK0(lsetxattr(path, name, value, size, flags), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_set_link (path, EXTATTR_NAMESPACE_USER,
-                             name, value, size), errno);
+    return FS_RET_CHECK(
+        extattr_set_link(path, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_setxattr (path, name, value, size, flags),
-                             errno);
+    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 FS_RET_CHECK0(setxattr (path, name, value, size, 0,
-                             (flags & ~XATTR_NOSECURITY) | XATTR_NOFOLLOW),
-                             errno);
+    /* 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 FS_RET_CHECK(llistxattr (path, list, size), errno);
+    return FS_RET_CHECK(llistxattr(path, list, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        ssize_t ret = FS_RET_CHECK(extattr_list_link (path,
-                                                      EXTATTR_NAMESPACE_USER,
-                                                      list, size), errno);
-        gf_extattr_list_reshape (list, ret);
-        return ret;
+    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 FS_RET_CHECK(solaris_listxattr (path, list, size), errno);
+    return FS_RET_CHECK(solaris_listxattr(path, list, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK(listxattr (path, list, size, XATTR_NOFOLLOW),
-                            errno);
+    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 FS_RET_CHECK(lgetxattr (path, name, value, size), errno);
+    return FS_RET_CHECK(lgetxattr(path, name, value, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK(extattr_get_link (path, EXTATTR_NAMESPACE_USER,
-                                              name, value, size), errno);
+    return FS_RET_CHECK(
+        extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK(solaris_getxattr (path, name, value, size), errno);
+    return FS_RET_CHECK(solaris_getxattr(path, name, value, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-         return FS_RET_CHECK(getxattr (path, name, value, size, 0,
-                                       XATTR_NOFOLLOW), errno);
+    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 FS_RET_CHECK(fgetxattr (filedes, name, value, size), errno);
+    return FS_RET_CHECK(fgetxattr(filedes, name, value, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK(extattr_get_fd (filedes, EXTATTR_NAMESPACE_USER,
-                            name, value, size), errno);
+    return FS_RET_CHECK(
+        extattr_get_fd(filedes, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK(solaris_fgetxattr (filedes, name, value, size),
-                            errno);
+    return FS_RET_CHECK(solaris_fgetxattr(filedes, name, value, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK(fgetxattr (filedes, name, value, size, 0, 0),
-                            errno);
+    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 FS_RET_CHECK0(fremovexattr (filedes, name), errno);
+    return FS_RET_CHECK0(fremovexattr(filedes, name), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_delete_fd (filedes, EXTATTR_NAMESPACE_USER,
-                                                name), errno);
+    return FS_RET_CHECK0(
+        extattr_delete_fd(filedes, EXTATTR_NAMESPACE_USER, name), errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_fremovexattr (filedes, name), errno);
+    return FS_RET_CHECK0(solaris_fremovexattr(filedes, name), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(fremovexattr (filedes, name, 0), errno);
+    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 FS_RET_CHECK0(fsetxattr (filedes, name, value, size, flags),
-                             errno);
+    return FS_RET_CHECK0(fsetxattr(filedes, name, value, size, flags), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_set_fd (filedes, EXTATTR_NAMESPACE_USER,
-                                             name, value, size), errno);
+    return FS_RET_CHECK(
+        extattr_set_fd(filedes, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_fsetxattr (filedes, name, value, size,
-                                                flags), errno);
+    return FS_RET_CHECK0(solaris_fsetxattr(filedes, name, value, size, flags),
+                         errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(fsetxattr (filedes, name, value, size, 0,
-                                        flags & ~XATTR_NOSECURITY), errno);
+    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 FS_RET_CHECK(flistxattr (filedes, list, size), errno);
+    return FS_RET_CHECK(flistxattr(filedes, list, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        ssize_t ret = FS_RET_CHECK (extattr_list_fd (filedes,
-                                                     EXTATTR_NAMESPACE_USER,
-                                                     list, size), errno);
-        gf_extattr_list_reshape (list, ret);
-        return ret;
+    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 FS_RET_CHECK(solaris_flistxattr (filedes, list, size), errno);
+    return FS_RET_CHECK(solaris_flistxattr(filedes, list, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK(flistxattr (filedes, list, size, XATTR_NOFOLLOW),
-                            errno);
+    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 FS_RET_CHECK0(lremovexattr (path, name), errno);
+    return FS_RET_CHECK0(lremovexattr(path, name), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_delete_link (path, EXTATTR_NAMESPACE_USER,
-                                                  name), errno);
+    return FS_RET_CHECK0(
+        extattr_delete_link(path, EXTATTR_NAMESPACE_USER, name), errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_removexattr (path, name), errno);
+    return FS_RET_CHECK0(solaris_removexattr(path, name), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(removexattr (path, name, XATTR_NOFOLLOW), errno);
+    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 FS_RET_CHECK0(access (pathname, mode), errno);
+    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 FS_RET_CHECK0(fallocate(fd, mode, offset, len), errno);
+    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 FS_RET_CHECK_ERRNO(posix_fallocate(fd, offset, len), errno);
+    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 FS_RET_CHECK0(ftruncate (fd, offset + len), errno);
-#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 032ff70ffb6..00000000000
--- a/libglusterfs/src/syscall.h
+++ /dev/null
@@ -1,225 +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_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);
-
-#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 68ac7b0edff..66c861b04cd 100644
--- a/libglusterfs/src/timer.c
+++ b/libglusterfs/src/timer.c
@@ -8,274 +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) || (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;
-        }
+    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;
-        }
-
-        if (ctx->cleanup_started) {
-                gf_msg_callingfn ("timer", GF_LOG_INFO, 0,
-                                  LG_MSG_CTX_CLEANUP_STARTED,
-                                  "ctx cleanup started");
-                return 0;
-        }
-
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-        }
-        UNLOCK (&ctx->lock);
+    gf_timer_registry_t *reg = NULL;
+    gf_boolean_t fired = _gf_false;
 
-        if (!reg) {
-                /* This can happen when cleanup may have just started and
-                 * gf_timer_registry_destroy() sets ctx->timer to NULL.
-                 * Just bail out as success as gf_timer_proc() takes
-                 * care of cleaning up the events.
-                 */
-                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;
-        struct timespec sleepts;
-        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;
-
-                        /*
-                         * This will be overridden with a shorter interval if
-                         * there's an event scheduled sooner. That makes the
-                         * system more responsive in most cases, but doesn't
-                         * include the case where a timer is added while we're
-                         * asleep. It's tempting to use pthread_cond_timedwait,
-                         * with the caveat that we'd be relying on system time
-                         * instead of monotonic time. That's a mess when the
-                         * system time is adjusted.  Another alternative might
-                         * be to use pthread_kill, but that will remain TBD for
-                         * now.
-                         */
-                        sleepts.tv_sec = 1;
-                        sleepts.tv_nsec = 0;
-
-                        LOCK (&reg->lock);
-                        {
-                                /*
-                                 * Using list_for_each and then always breaking
-                                 * after the first iteration might seem strange,
-                                 * but (unlike alternatives) is independent of
-                                 * the underlying list implementation.
-                                 */
-                                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);
-                                        } else {
-                                                uint64_t diff = now - at;
-
-                                                if (diff < 1000000000) {
-                                                        sleepts.tv_sec = 0;
-                                                        sleepts.tv_nsec = diff;
-                                                }
-                                        }
-                                        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;
-        int ret = -1;
-
-        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);
+    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;
         }
-        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");
+        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");
+    }
 
 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 932a18c0103..96cef5c6f07 100644
--- a/libglusterfs/src/timespec.c
+++ b/libglusterfs/src/timespec.c
@@ -19,70 +19,111 @@
 static mach_timebase_info_data_t gf_timebase;
 #endif
 
-#include "logging.h"
-#include "timespec.h"
-#include "libglusterfs-messages.h"
-#include "common-utils.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)) {
-                /* 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!!");
+#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)
+{
+#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_adjust_delta(struct timespec *ts, struct timespec delta)
+{
+    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)
 {
-        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 (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;
+    }
 }
 
-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)
 {
-        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;
-        }
+    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 48d10382c10..00000000000
--- a/libglusterfs/src/upcall-utils.h
+++ /dev/null
@@ -1,108 +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_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/xlator.c b/libglusterfs/src/xlator.c
index b1a79a68bf5..9a2582d45d5 100644
--- a/libglusterfs/src/xlator.c
+++ b/libglusterfs/src/xlator.c
@@ -8,610 +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;                    \
-                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)
+#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 struct xlator_cbks default_cbks = { };
+static struct xlator_cbks default_cbks = {};
 struct volume_options default_options[] = {
-        { .key   = {NULL} },
+    {
+        .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},
+    },
 };
 
-static void
-fill_defaults (xlator_t *xl)
+/* 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;
 
-        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);
-
-        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;
+    /* 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;
+        }
+    }
+}
 
+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;
-        xlator_api_t  *xlapi = 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
-                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_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                        "%s", dlerror ());
-                goto 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");
+        xlapi = dlsym(handle, "xlator_api");
         if (!xlapi) {
-                gf_msg ("xlator", GF_LOG_DEBUG, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(xlator_api) on %s. "
-                        "Fall back to old symbols", dlerror ());
-                /* This case is not an error for now, so allow it
-                   to fall back to old methods. */
-                opt_list->given_opt = dlsym (handle, "options");
-                if (!opt_list->given_opt) {
-                        dlerror ();
-                        gf_msg ("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
-                                "Failed to load xlator opt table");
-                        goto out;
-                }
-        } else {
-                opt_list->given_opt = xlapi->options;
-                if (!opt_list->given_opt) {
-                        gf_msg ("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
-                                "Failed to load xlator options table");
-                        goto out;
-                }
-        }
-
-        *dl_handle = handle;
-        handle = NULL;
-
-        ret = 0;
- out:
-        GF_FREE (name);
-        if (handle)
-                dlclose (handle);
-
-        gf_msg_debug ("xlator", 0, "Returning %d", ret);
-        return ret;
-
-}
-
-int xlator_dynload_oldway (xlator_t *xl)
-{
-        int                i = 0;
-        int                ret = -1;
-        void              *handle = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        class_methods_t   *vtbl = NULL;
-
-        handle = xl->dlhandle;
-
-        xl->fops = dlsym (handle, "fops");
-        if (!xl->fops) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(fops) on %s", dlerror ());
-                goto out;
+            gf_smsg("xlator", GF_LOG_ERROR, 0, LG_MSG_DLSYM_ERROR, "error=%s",
+                    dlerror(), NULL);
+            goto out;
         }
 
-        xl->cbks = dlsym (handle, "cbks");
-        if (!xl->cbks) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(cbks) on %s", dlerror ());
-                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;
         }
-
-        /*
-         * 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 {
+        opt = dlsym(handle, "options");
+        if (!opt) {
+            gf_smsg("xlator", GF_LOG_ERROR, 0, LG_MSG_DLSYM_ERROR, "error=%s",
+                    dlerror(), NULL);
+            goto out;
         }
-        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 ());
-                }
 
-        }
+        opt_list->given_opt = opt;
+    }
 
-        if (!(xl->dumpops = dlsym (handle, "dumpops"))) {
-                gf_msg_trace ("xlator", 0, "dlsym(dumpops) on %s -- "
-                              "neglecting", dlerror ());
-        }
+    *dl_handle = handle;
+    handle = NULL;
 
-        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 ());
-        }
+    ret = 0;
+out:
+    GF_FREE(name);
+    if (handle)
+        dlclose(handle);
 
-        vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                             gf_common_mt_volume_opt_list_t);
+    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;
+            goto out;
         }
+        INIT_LIST_HEAD(&vol_opt->list);
 
-        if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
-                gf_msg_trace (xl->name, 0, "Strict option validation not "
-                              "enforced -- neglecting (%s)", dlerror ());
-        }
-        INIT_LIST_HEAD (&vol_opt->list);
-        list_add_tail (&vol_opt->list, &xl->volume_options);
+        vol_opt->given_opt = xlapi->options;
+        list_add_tail(&vol_opt->list, &xl->volume_options);
+    }
 
-        /* make sure 'min' is set to high value, so it would be
-           properly set later */
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                xl->stats.interval.latencies[i].min = 0xffffffff;
-        }
+    xl->id = xlapi->xlator_id;
+    xl->flags = xlapi->flags;
+    xl->identifier = xlapi->identifier;
+    xl->category = xlapi->category;
 
-        ret = 0;
+    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;
+    return ret;
 }
 
-int xlator_dynload_newway (xlator_t *xl)
+int
+xlator_dynload(xlator_t *xl)
 {
-        int                ret = -1;
-        void              *handle = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        xlator_api_t      *xlapi = NULL;
+    int ret = -1;
+    char *name = NULL;
+    void *handle = NULL;
 
-        handle = xl->dlhandle;
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        xlapi = dlsym (handle, "xlator_api");
-        if (!xlapi) {
-                gf_msg ("xlator", GF_LOG_INFO, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(xlator_api) on %s. "
-                        "Fall back to old symbols", dlerror ());
-                /* This case is not an error for now, so allow it
-                   to fall back to old methods. */
-                ret = 1;
-                goto out;
-        }
+    INIT_LIST_HEAD(&xl->volume_options);
 
-        xl->fops = xlapi->fops;
-        if (!xl->fops) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "%s: struct missing (fops)", xl->name);
-                goto out;
-        }
+    ret = gf_asprintf(&name, "%s/%s.so", XLATORDIR, xl->type);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        xl->cbks = xlapi->cbks;
-        if (!xl->cbks) {
-                gf_msg_trace ("xlator", 0, "%s: struct missing (cbks)",
-                              xl->name);
-        }
+    ret = -1;
 
-        xl->init = xlapi->init;
-        if (!xl->init) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "%s: method missing (init)", xl->name);
-                goto out;
-        }
+    gf_msg_trace("xlator", 0, "attempt to load file %s", name);
 
-        xl->fini = xlapi->fini;
-        if (!xl->fini) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (fini)",
-                              xl->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;
+    }
+    xl->dlhandle = handle;
 
-        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);
-        }
+    ret = xlator_dynload_apis(xl);
+    if (-1 == ret)
+        goto out;
 
-        xl->dump_metrics = xlapi->dump_metrics;
-        if (!xl->dump_metrics) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (dump_metrics)",
-                              xl->name);
-        }
+    fill_defaults(xl);
 
-        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;
-        }
-
-        vol_opt->given_opt = xlapi->options;
-        if (!vol_opt->given_opt) {
-                gf_msg ("xlator", GF_LOG_INFO, 0, LG_MSG_DLSYM_ERROR,
-                        "%s: options not provided, using default", xl->name);
-                vol_opt->given_opt = default_options;
-        }
-
-        INIT_LIST_HEAD (&vol_opt->list);
-        list_add_tail (&vol_opt->list, &xl->volume_options);
+    ret = 0;
 
-        xl->id         = xlapi->xlator_id;
-        xl->flags      = xlapi->flags;
-        xl->identifier = xlapi->identifier;
-        memcpy (xl->op_version, xlapi->op_version,
-                sizeof (uint32_t) * GF_MAX_RELEASES);
-
-        ret = 0;
 out:
-        return ret;
+    GF_FREE(name);
+    return ret;
 }
 
-
 int
-xlator_dynload (xlator_t *xl)
+xlator_set_type(xlator_t *xl, const char *type)
 {
-        int                ret = -1;
-        char              *name = NULL;
-        void              *handle = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    /* Handle 'global' translator differently */
+    if (!strncmp(GF_GLOBAL_XLATOR_NAME, type, SLEN(GF_GLOBAL_XLATOR_NAME))) {
+        volume_opt_list_t *vol_opt = NULL;
 
-        INIT_LIST_HEAD (&xl->volume_options);
+        /* 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;
 
-        ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xl->type);
-        if (-1 == ret) {
-                goto out;
+        vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                            gf_common_mt_volume_opt_list_t);
+        if (!vol_opt) {
+            ret = -1;
+            goto out;
         }
 
-        ret = -1;
-
-        gf_msg_trace ("xlator", 0, "attempt to load file %s", name);
-
-        handle = dlopen (name, RTLD_NOW);
-        if (!handle) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                        "%s", dlerror ());
-                goto out;
-        }
-        xl->dlhandle = handle;
-
-        ret = xlator_dynload_newway (xl);
-        if (-1 == ret)
-                goto out;
-        if (1 == ret) {
-                /* it means we don't find the new symbol in xlator code */
-                ret = xlator_dynload_oldway (xl);
-                if (-1 == ret)
-                        goto out;
-        }
+        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;
-
-        /* Handle 'global' translator differently */
-        if (!strncmp (GF_GLOBAL_XLATOR_NAME, type,
-                      strlen (GF_GLOBAL_XLATOR_NAME))) {
-                volume_opt_list_t *vol_opt = NULL;
-
-                /* 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) {
-                        ret = -1;
-                        goto out;
-                }
-
-                vol_opt->given_opt = global_xl_options;
-
-                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:
-        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
@@ -621,295 +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) && !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;
+    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;
 }
 
 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;
-        int       fop_idx = 0;
+    xlator_t *old_THIS = NULL;
+    int ret = 0;
+    int fop_idx = 0;
 
-        old_THIS = THIS;
-        THIS = xl;
+    old_THIS = THIS;
+    THIS = xl;
 
-        /* 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);
+    /* 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);
 
-                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);
+        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);
 
-        xlator_init_lock ();
-        ret = xl->init (xl);
-        xlator_init_unlock ();
+    xlator_init_lock();
+    handle_default_options(xl, xl->options);
+    ret = xl->init(xl);
+    xlator_init_unlock();
 
-        THIS = old_THIS;
+    THIS = old_THIS;
 
-        return ret;
+    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;
-        }
+    if (ret) {
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR, "name=%s",
+                xl->name, NULL);
+        goto out;
+    }
 
-        xl->init_succeeded = 1;
-        /*xl->cleanup_starting = 0;
-          xl->call_cleanup = 0;
-        */
-        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;
+        xlator_fini_rec(trav->xlator);
+        gf_msg_debug(trav->xlator->name, 0, "fini done");
+        trav = trav->next;
+    }
 
-                        xl->fini (xl);
+    xl->cleanup_starting = 1;
+    if (xl->init_succeeded) {
+        if (xl->fini) {
+            old_THIS = THIS;
+            THIS = xl;
 
-                        if (xl->local_pool)
-                                mem_pool_destroy (xl->local_pool);
+            xl->fini(xl);
 
-                        THIS = old_THIS;
-                } else {
-                        gf_msg_debug (xl->name, 0, "No fini() found");
-                }
-                xl->init_succeeded = 0;
+            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));
+        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;
 }
 
 int
-xlator_memrec_free (xlator_t *xl)
+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
@@ -938,609 +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;
+    return 0;
 }
 
 static int
-xlator_mem_free (xlator_t *xl)
+xlator_mem_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;
 
-        if (xl->options) {
-                dict_ref (xl->options);
-                dict_unref (xl->options);
-                xl->options = NULL;
-        }
+    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);
-        }
+    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);
+    xlator_memrec_free(xl);
 
-        return 0;
+    return 0;
 }
 
 static void
-xlator_call_fini (xlator_t *this) {
-        if (!this || this->cleanup_starting)
-                return;
-        this->cleanup_starting = 1;
-        this->call_cleanup = 1;
-        xlator_call_fini (this->next);
-        this->fini (this);
+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
-xlator_mem_cleanup (xlator_t *this) {
-        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;
-
-
-        if (this->call_cleanup || !this->ctx)
-                return;
-
-        this->call_cleanup = 1;
-        ctx = this->ctx;
-
-        xlator_call_fini (trav);
+xlator_mem_cleanup(xlator_t *this)
+{
+    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 (graph_cleanup) {
+        prev = this;
+        graph = ctx->active;
+        pthread_mutex_lock(&graph->mutex);
         while (prev) {
-                trav = prev->next;
-                xlator_mem_free (prev);
-                prev = trav;
-        }
-
-        inode_table = this->itable;
-        if (inode_table) {
-                inode_table_destroy (inode_table);
-                this->itable = NULL;
-        }
-
-        if (this->fini) {
-                this->fini (this);
-        }
-
-        xlator_mem_free (this);
-
-        if (ctx->active) {
-                top = ctx->active->first;
-                LOCK (&ctx->volfile_lock);
-                /* TODO here we have leak for xlator node in a graph */
-                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)) {
-                                        (*trav_p) = (*trav_p)->next;
-                                        break;
-                        }
-                }
-                /* TODO Sometime brick xlator is not moved from graph so followed below
-                   approach to move brick xlator from a graph, will move specific brick
-                   xlator from graph only while inode table and mem_acct are cleaned up
-                */
-                trav_p = &top->children;
-                while (*trav_p) {
-                        victim = (*trav_p)->xlator;
-                        if (victim->call_cleanup && !victim->itable && !victim->mem_acct) {
-                                (*trav_p) = (*trav_p)->next;
-                        } else {
-                                trav_p = &(*trav_p)->next;
-                        }
-                }
-                UNLOCK (&ctx->volfile_lock);
+            trav = prev->next;
+            GF_FREE(prev);
+            prev = trav;
         }
+        pthread_mutex_unlock(&graph->mutex);
+    }
 }
 
 void
-loc_wipe (loc_t *loc)
+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));
+    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;
 }
 
+static int32_t
+gf_bin_to_string(char *dst, size_t size, void *src, size_t len)
+{
+    if (len >= size) {
+        return EINVAL;
+    }
+
+    memcpy(dst, src, len);
+    dst[len] = 0;
+
+    return 0;
+}
 
 int
-is_gf_log_command (xlator_t *this, const char *name, char *value)
+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_string2boolean (value, &syslog_flag);
-                if (ret) {
-                        ret = EOPNOTSUPP;
-                        goto out;
-                }
-                if (syslog_flag)
-                        gf_log_enable_syslog ();
-                else
-                        gf_log_disable_syslog ();
-
-                goto out;
+    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;
+        }
+        ret = gf_string2boolean(key, &syslog_flag);
+        if (ret) {
+            ret = EOPNOTSUPP;
+            goto out;
         }
+        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;
+}
 
-        if (fnmatch ("trusted.glusterfs*set-log-level", name, FNM_NOESCAPE))
-                goto out;
+int
+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_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_INIT, NULL);
+
+    return log_level;
+}
 
-        log_level = glusterd_check_log_level (value);
-        if (log_level == -1) {
-                ret = EOPNOTSUPP;
-                goto out;
-        }
+int
+xlator_subvolume_count(xlator_t *this)
+{
+    int i = 0;
+    xlator_list_t *list = NULL;
 
-        /* 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 (this->ctx, log_level);
-                ret = 0;
-                goto out;
-        }
+    for (list = this->children; list; list = list->next)
+        i++;
+    return i;
+}
 
-        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;
-        }
+static int
+_copy_opt_to_child(dict_t *options, char *key, data_t *value, void *data)
+{
+    xlator_t *child = data;
 
-        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;
-        }
-out:
-        return ret;
+    gf_log(__func__, GF_LOG_DEBUG, "copying %s to child %s", key, child->name);
+    dict_set(child->options, key, value);
+
+    return 0;
 }
 
+int
+copy_opts_to_child(xlator_t *src, xlator_t *dst, char *glob)
+{
+    return dict_foreach_fnmatch(src->options, glob, _copy_opt_to_child, dst);
+}
 
 int
-glusterd_check_log_level (const char *value)
+glusterfs_delete_volfile_checksum(glusterfs_ctx_t *ctx, const char *volfile_id)
 {
-        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;
-        }
+    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 (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");
+/*
+   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.
 
-        return log_level;
-}
+*/
 
-int
-xlator_subvolume_count (xlator_t *this)
+void
+gluster_graph_take_reference(xlator_t *tree)
 {
-        int i = 0;
-        xlator_list_t *list = NULL;
+    xlator_t *trav = tree;
+    xlator_t *prev = tree;
 
-        for (list = this->children; list; list = list->next)
-                i++;
-        return i;
+    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;
 }
 
-static int
-_copy_opt_to_child (dict_t *options, char *key, data_t *value, void *data)
+gf_boolean_t
+mgmt_is_multiplexed_daemon(char *name)
 {
-        xlator_t        *child = data;
+    const char *mux_daemons[] = {"glustershd", NULL};
+    int i;
 
-        gf_log (__func__, GF_LOG_DEBUG,
-                "copying %s to child %s", key, child->name);
-        dict_set (child->options, key, value);
+    if (!name)
+        return _gf_false;
 
-        return 0;
+    for (i = 0; mux_daemons[i]; i++) {
+        if (!strcmp(name, mux_daemons[i]))
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
-int
-copy_opts_to_child (xlator_t *src, xlator_t *dst, char *glob)
+gf_boolean_t
+xlator_is_cleanup_starting(xlator_t *this)
 {
-        return dict_foreach_fnmatch (src->options, glob,
-                                     _copy_opt_to_child, dst);
+    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
-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;
-                }
-        }
+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;
+    }
 
-        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);
+    while (xl) {
+        if (strcmp(xl->type, "protocol/client") == 0) {
+            count++;
         }
-
-        return 0;
+        xl = xl->next;
+    }
+out:
+    return count;
 }
diff --git a/libglusterfs/src/xlator.h b/libglusterfs/src/xlator.h
deleted file mode 100644
index d476cf26442..00000000000
--- a/libglusterfs/src/xlator.h
+++ /dev/null
@@ -1,1253 +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_SET_ATTR_CTIME 0x40
-
-#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 "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_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_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);
-
-/* 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;
-
-        /* 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;
-};
-
-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,
-                 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 */
-                        fop_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;
-
-
-};
-
-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;
-
-/* 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;
-
-        /* 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);
-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);
-int
-xlator_memrec_free (xlator_t *xl);
-
-void
-xlator_mem_cleanup (xlator_t *this);
-#endif /* _XLATOR_H */
diff --git a/rfc.sh b/rfc.sh
index bb28f08dccc..e7faec9ea0f 100755
--- a/rfc.sh
+++ b/rfc.sh
@@ -4,7 +4,29 @@
 # i.e. where we are interested in the result of a command,
 # we have to run the command in an if-statement.
 
-ORIGIN=${GLUSTER_ORIGIN:-origin}
+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
@@ -18,7 +40,7 @@ done
 shift $((OPTIND-1))
 
 
-branch="master";
+branch="devel";
 
 set_hooks_commit_msg()
 {
@@ -50,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 ""
 }
 
@@ -72,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
@@ -86,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
@@ -116,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
@@ -130,42 +193,32 @@ editor_mode()
     if [ $(basename "$1") = "COMMIT_EDITMSG" ]; then
         # see note above function warn_reference_missing for regex elaboration
         # Lets first check for github issues
-        ref=$(git show --format='%b' | grep -ow -E "([fF][iI][xX][eE][sS]|[uU][pP][dD][aA][tT][eE][sS])(:)?[[:space:]]+(gluster\/glusterfs)?#[[:digit:]]+" | awk -F '#' '{print $2}');
-        if [ "x${ref}" = "x" ]; then
-            # if not found, check for bugs
-            ref=$(git show --format='%b' | grep -ow -E "([fF][iI][xX][eE][sS]|[uU][pP][dD][aA][tT][eE][sS])(:)?[[:space:]]+bz#[[:digit:]]+" | awk -F '#' '{print $2}');
-        fi
-
+        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 "Reference (Bugzilla ID or Github Issue 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 reference ID ($bug)!!!";
+            if ! is_num "$issue"; then
+                echo "Invalid Github Issue ID!!!";
                 continue;
             fi
 
-            bz_string="bz"
-            if [ $bug -lt 742000 ]; then
-                bz_string=""
-            fi
-
-            echo "Select yes '(y)' if this patch fixes the bug/feature completely,"
+            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"
+            fixes_string="Fixes"
             if [ "${fixes}" = 'N' ] || [ "${fixes}" = 'n' ]; then
-                fixes_string="updates"
+                fixes_string="Updates"
             fi
 
-            sed "/^Change-Id:/{p; s/^.*$/${fixes_string}: ${bz_string}#${bug}/;}" $1 > $1.new && \
+            sed "/^Change-Id:/{p; s/^.*$/${fixes_string}: #${issue}/;}" $1 > $1.new && \
                 mv $1.new $1;
             return;
         done
@@ -181,109 +234,33 @@ 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
-}
-
-# 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 ;
-#
-#   [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
 warn_reference_missing()
 {
     echo ""
     echo "=== Missing a reference in commit! ==="
     echo ""
-    echo "Gluster commits are made with a reference to a bug or a github issue"
+    echo "Gluster commits are made with a reference to a github issue"
     echo ""
-    echo "Submissions that are enhancements (IOW, not functional"
-    echo "bug fixes, but improvements of any nature to the code) are tracked"
-    echo "using github issues [1]."
+    echo "A check on the commit message, reveals that there is no "
+    echo "github issue referenced in the commit message."
     echo ""
-    echo "Submissions that are bug fixes are tracked using Bugzilla [2]."
+    echo "https://github.com/gluster/glusterfs/issues/new"
     echo ""
-    echo "A check on the commit message, reveals that there is no bug or"
-    echo "github issue referenced in the commit message"
+    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 "[2] https://bugzilla.redhat.com/enter_bug.cgi?product=GlusterFS"
-    echo ""
-    echo "Please file an issue or a bug report and reference the same in the"
-    echo "commit message using the following tags:"
-    echo "GitHub Issues:"
-    echo "\"Fixes: gluster/glusterfs#n\" OR \"Updates: gluster/glusterfs#n\","
-    echo "\"Fixes: #n\" OR \"Updates: #n\","
-    echo "Bugzilla ID:"
-    echo "\"Fixes: bz#n\" OR \"Updates: bz#n\","
-    echo "where n is the issue or bug number"
+    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."
     echo ""
-    echo -n "Missing reference to a bug or a github issue. Continue (y/N): "
+    echo -n "Missing reference to a github issue. Continue (y/N): "
     read moveon
     if [ "${moveon}" = 'Y' ] || [ "${moveon}" = 'y' ]; then
         return;
@@ -303,7 +280,7 @@ main()
         return;
     fi
 
-    check_patches_for_coding_style;
+    git fetch $UPSTREAM;
 
     rebase_changes;
 
@@ -311,15 +288,32 @@ main()
 
     assert_diverge;
 
-    # see note above function warn_reference_missing for regex elaboration
-    reference=$(git show --format='%b' | grep -ow -E "([fF][iI][xX][eE][sS]|[uU][pP][dD][aA][tT][eE][sS])(:)?[[:space:]]+(gluster\/glusterfs)?(bz)?#[[:digit:]]+" | awk -F '#' '{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 or a github
+    # 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 = "master" ]; then
+    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'
     else
@@ -327,9 +321,9 @@ main()
     fi
 
     if [ -z "${reference}" ]; then
-        $drier git push $ORIGIN HEAD:refs/for/$branch/rfc;
+        $drier git push $USER_REPO HEAD:temp_${branch}/$(date +%Y-%m-%d_%s);
     else
-        $drier git push $ORIGIN HEAD:refs/for/$branch/ref-${reference};
+        $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 81a96476883..35c9db07e7f 100644
--- a/rpc/rpc-lib/src/Makefile.am
+++ b/rpc/rpc-lib/src/Makefile.am
@@ -2,7 +2,7 @@ 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
diff --git a/rpc/rpc-lib/src/auth-glusterfs.c b/rpc/rpc-lib/src/auth-glusterfs.c
index 78f283557b0..69a96f7512f 100644
--- a/rpc/rpc-lib/src/auth-glusterfs.c
+++ b/rpc/rpc-lib/src/auth-glusterfs.c
@@ -8,11 +8,8 @@
   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"
@@ -21,386 +18,369 @@
 /* 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,
-                                                   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;
+    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
-};
-
-rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {
-        .authname       = "AUTH_GLUSTERFS-v2",
-        .authnum        = AUTH_GLUSTERFS_v2,
-        .authops        = &auth_glusterfs_ops_v2,
-        .authprivate    = NULL
-};
+    .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)
+rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs_v2;
+    return &rpcsvc_auth_glusterfs_v2;
 }
 
 /* V3 */
 
 ssize_t
-xdr_to_glusterfs_auth_v3 (char *buf, struct auth_glusterfs_params_v3 *req)
+xdr_to_glusterfs_auth_v3(char *buf, struct auth_glusterfs_params_v3 *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_params_v3 (&xdr, req)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs v3 parameters");
-                ret  = -1;
-                goto ret;
-        }
+    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 = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
 ret:
-        return ret;
+    return ret;
 }
 
 int
-auth_glusterfs_v3_request_init (rpcsvc_request_t *req, void *priv)
+auth_glusterfs_v3_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_glusterfs_v3_authenticate (rpcsvc_request_t *req, void *priv)
+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;
+    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);
+    /* 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_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
-};
+    .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_v3_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs_v3;
+    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
index 4840fd4e971..a954ae7a27a 100644
--- a/rpc/rpc-lib/src/autoscale-threads.c
+++ b/rpc/rpc-lib/src/autoscale-threads.c
@@ -8,16 +8,15 @@
    cases as published by the Free Software Foundation.
 */
 
-#include "gf-event.h"
+#include <glusterfs/gf-event.h>
 #include "rpcsvc.h"
 
 void
-rpcsvc_autoscale_threads (glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr)
+rpcsvc_autoscale_threads(glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr)
 {
-        struct event_pool       *pool           = ctx->event_pool;
-        int                      thread_count   = pool->eventthreadcount;
+    struct event_pool *pool = ctx->event_pool;
+    int thread_count = pool->eventthreadcount;
 
-        pool->auto_thread_count += incr;
-        (void) event_reconfigure_threads (pool, thread_count+incr);
-        rpcsvc_ownthread_reconf (rpc, 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
index a7cb5f6b5cb..e026d80259b 100644
--- a/rpc/rpc-lib/src/libgfrpc.sym
+++ b/rpc/rpc-lib/src/libgfrpc.sym
@@ -3,7 +3,6 @@ rpcclnt_cbk_program_register
 rpc_clnt_cleanup_and_start
 rpc_clnt_connection_cleanup
 rpc_clnt_disable
-rpc_clnt_disconnect
 rpc_clnt_new
 rpc_clnt_reconfig
 rpc_clnt_reconnect
@@ -26,6 +25,7 @@ rpcsvc_drc_priv
 rpcsvc_drc_reconfigure
 rpcsvc_get_program_vector_sizer
 rpcsvc_init
+rpcsvc_destroy
 rpcsvc_init_options
 rpcsvc_listener_destroy
 rpcsvc_program_register
@@ -51,7 +51,6 @@ rpcsvc_transport_connect
 rpcsvc_transport_getpeeraddr
 rpcsvc_unregister_notify
 rpcsvc_volume_allowed
-rpcsvc_ownthread_reconf
 rpc_transport_count
 rpc_transport_connect
 rpc_transport_disconnect
@@ -66,3 +65,4 @@ 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
index fbcc78a7a7e..25a7148e5a3 100644
--- a/rpc/rpc-lib/src/mgmt-pmap.c
+++ b/rpc/rpc-lib/src/mgmt-pmap.c
@@ -12,127 +12,136 @@
 #include "protocol-common.h"
 #include "rpc-clnt.h"
 #include "xdr-generic.h"
-#include "xlator.h"
 
 /* Defining a minimal RPC client program for portmap signout
  */
 char *clnt_pmap_signout_procs[GF_PMAP_MAXVALUE] = {
-        [GF_PMAP_SIGNOUT]     = "SIGNOUT",
+    [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,
+    .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)
+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 (-1 == rsp.op_ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                goto out;
-        }
+    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:
-        return 0;
+    if (frame) {
+        STACK_DESTROY(frame->root);
+    }
+
+    return 0;
 }
 
 int
-rpc_clnt_mgmt_pmap_signout (glusterfs_ctx_t *ctx, char *brickname)
+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);
+    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 (iobref)
+        iobref_unref(iobref);
 
-        if (iobuf)
-                iobuf_unref (iobuf);
-        return ret;
+    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 c26cb6966c7..0cb5862e9a9 100644
--- a/rpc/rpc-lib/src/protocol-common.h
+++ b/rpc/rpc-lib/src/protocol-common.h