Land part 2 of clang-format changes

Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>

3 files changed, 3062 insertions, 3051 deletions

diff --git a/xlators/storage/bd/src/bd-aio.c b/xlators/storage/bd/src/bd-aio.c
index 6f5c90f457e..6bc7d4a104c 100644
--- a/xlators/storage/bd/src/bd-aio.c
+++ b/xlators/storage/bd/src/bd-aio.c
@@ -27,495 +27,492 @@
 #include "bd-mem-types.h"
 
 struct bd_aio_cb {
-        struct iocb     iocb;
-        call_frame_t   *frame;
-        struct iobuf   *iobuf;
-        struct iobref  *iobref;
-        struct iatt     prebuf;
-        int             op;
-        off_t           offset;
-        fd_t           *fd;
+    struct iocb iocb;
+    call_frame_t *frame;
+    struct iobuf *iobuf;
+    struct iobref *iobref;
+    struct iatt prebuf;
+    int op;
+    off_t offset;
+    fd_t *fd;
 };
 
 void
-__bd_fd_set_odirect (fd_t *fd, bd_fd_t *bd_fd, int opflags,
-                     off_t offset, size_t size)
+__bd_fd_set_odirect(fd_t *fd, bd_fd_t *bd_fd, int opflags, off_t offset,
+                    size_t size)
 {
-        int odirect = 0;
-        int flags = 0;
-        int ret = 0;
-
-        odirect = bd_fd->odirect;
-
-        if ((fd->flags|opflags) & O_DIRECT) {
-                /* if instructed, use O_DIRECT always */
-                odirect = 1;
-        } else {
-                /* else use O_DIRECT when feasible */
-                if ((offset|size) & 0xfff)
-                        odirect = 0;
-                else
-                        odirect = 1;
-        }
-
-        if (!odirect && bd_fd->odirect) {
-                flags = fcntl (bd_fd->fd, F_GETFL);
-                ret = fcntl (bd_fd->fd, F_SETFL, (flags & (~O_DIRECT)));
-                bd_fd->odirect = 0;
-        }
-
-        if (odirect && !bd_fd->odirect) {
-                flags = fcntl (bd_fd->fd, F_GETFL);
-                ret = fcntl (bd_fd->fd, F_SETFL, (flags | O_DIRECT));
-                bd_fd->odirect = 1;
-        }
-
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "fcntl() failed (%s). fd=%d flags=%d pfd->odirect=%d",
-                        strerror (errno), bd_fd->fd, flags, bd_fd->odirect);
-        }
+    int odirect = 0;
+    int flags = 0;
+    int ret = 0;
+
+    odirect = bd_fd->odirect;
+
+    if ((fd->flags | opflags) & O_DIRECT) {
+        /* if instructed, use O_DIRECT always */
+        odirect = 1;
+    } else {
+        /* else use O_DIRECT when feasible */
+        if ((offset | size) & 0xfff)
+            odirect = 0;
+        else
+            odirect = 1;
+    }
+
+    if (!odirect && bd_fd->odirect) {
+        flags = fcntl(bd_fd->fd, F_GETFL);
+        ret = fcntl(bd_fd->fd, F_SETFL, (flags & (~O_DIRECT)));
+        bd_fd->odirect = 0;
+    }
+
+    if (odirect && !bd_fd->odirect) {
+        flags = fcntl(bd_fd->fd, F_GETFL);
+        ret = fcntl(bd_fd->fd, F_SETFL, (flags | O_DIRECT));
+        bd_fd->odirect = 1;
+    }
+
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "fcntl() failed (%s). fd=%d flags=%d pfd->odirect=%d",
+               strerror(errno), bd_fd->fd, flags, bd_fd->odirect);
+    }
 }
 
 int
-bd_aio_readv_complete (struct bd_aio_cb *paiocb, int res, int res2)
+bd_aio_readv_complete(struct bd_aio_cb *paiocb, int res, int res2)
 {
-        call_frame_t   *frame = NULL;
-        xlator_t       *this = NULL;
-        struct iobuf   *iobuf = NULL;
-        struct iatt     postbuf = {0,};
-        int             op_ret = -1;
-        int             op_errno = 0;
-        struct iovec    iov;
-        struct iobref  *iobref = NULL;
-        off_t           offset = 0;
-        bd_attr_t      *bdatt = NULL;
-
-        frame = paiocb->frame;
-        this = frame->this;
-        iobuf = paiocb->iobuf;
-        offset = paiocb->offset;
-
-        if (res < 0) {
-                op_ret = -1;
-                op_errno = -res;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)",
-                        paiocb->fd, paiocb->iocb.u.c.nbytes,
-                        (unsigned long long) paiocb->offset,
-                        res, strerror (op_errno));
-                goto out;
-        }
-
-        bd_inode_ctx_get (paiocb->fd->inode, this, &bdatt);
-        memcpy (&postbuf, &bdatt->iatt, sizeof (struct iatt));
-
-        op_ret = res;
-        op_errno = 0;
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                op_ret = -1;
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        iobref_add (iobref, iobuf);
-
-        iov.iov_base = iobuf_ptr (iobuf);
-        iov.iov_len = op_ret;
-
-        /* Hack to notify higher layers of EOF. */
-        if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size)
-                op_errno = ENOENT;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iatt postbuf = {
+        0,
+    };
+    int op_ret = -1;
+    int op_errno = 0;
+    struct iovec iov;
+    struct iobref *iobref = NULL;
+    off_t offset = 0;
+    bd_attr_t *bdatt = NULL;
+
+    frame = paiocb->frame;
+    this = frame->this;
+    iobuf = paiocb->iobuf;
+    offset = paiocb->offset;
+
+    if (res < 0) {
+        op_ret = -1;
+        op_errno = -res;
+        gf_log(this->name, GF_LOG_ERROR,
+               "readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)",
+               paiocb->fd, paiocb->iocb.u.c.nbytes,
+               (unsigned long long)paiocb->offset, res, strerror(op_errno));
+        goto out;
+    }
+
+    bd_inode_ctx_get(paiocb->fd->inode, this, &bdatt);
+    memcpy(&postbuf, &bdatt->iatt, sizeof(struct iatt));
+
+    op_ret = res;
+    op_errno = 0;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        op_ret = -1;
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    iobref_add(iobref, iobuf);
+
+    iov.iov_base = iobuf_ptr(iobuf);
+    iov.iov_len = op_ret;
+
+    /* Hack to notify higher layers of EOF. */
+    if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size)
+        op_errno = ENOENT;
 
 out:
-        STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, &iov, 1,
-                             &postbuf, iobref, NULL);
-        if (iobuf)
-                iobuf_unref (iobuf);
-        if (iobref)
-                iobref_unref (iobref);
+    STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, &iov, 1, &postbuf,
+                        iobref, NULL);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    if (iobref)
+        iobref_unref(iobref);
 
-        GF_FREE (paiocb);
+    GF_FREE(paiocb);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_aio_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 size_t size, off_t offset, uint32_t flags, dict_t *xdata)
+bd_aio_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             op_errno   = EINVAL;
-        int                 _fd        = -1;
-        struct iobuf       *iobuf      = NULL;
-        bd_fd_t            *bd_fd      = NULL;
-        int                 ret        = -1;
-        struct bd_aio_cb   *paiocb     = NULL;
-        bd_priv_t          *priv       = NULL;
-        struct iocb        *iocb       = NULL;
-        bd_attr_t          *bdatt      = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        priv = this->private;
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd) {
-                STACK_WIND (frame, default_readv_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->readv, fd, size, offset,
-                            flags, xdata);
-                return 0;
-        }
-        _fd = bd_fd->fd;
-        bd_inode_ctx_get (fd->inode, this, &bdatt);
-        if (!size) {
-                op_errno = EINVAL;
-                gf_log (this->name, GF_LOG_WARNING, "size=%"GF_PRI_SIZET, size);
-                goto err;
-        }
-
-        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-        if (!iobuf) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        paiocb = GF_CALLOC (1, sizeof (*paiocb), gf_bd_aio_cb);
-        if (!paiocb) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        paiocb->frame = frame;
-        paiocb->iobuf = iobuf;
-        paiocb->offset = offset;
-        paiocb->op = GF_FOP_READ;
-        paiocb->fd = fd;
-
-        paiocb->iocb.data = paiocb;
-        paiocb->iocb.aio_fildes = _fd;
-        paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD;
-        paiocb->iocb.aio_reqprio = 0;
-        paiocb->iocb.u.c.buf = iobuf_ptr (iobuf);
-        paiocb->iocb.u.c.nbytes = size;
-        paiocb->iocb.u.c.offset = offset;
-
-        iocb = &paiocb->iocb;
-
-        LOCK (&fd->lock);
-        {
-                __bd_fd_set_odirect (fd, bd_fd, flags, offset, size);
-
-                ret = io_submit (priv->ctxp, 1, &iocb);
-        }
-        UNLOCK (&fd->lock);
-
-        if (ret != 1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "io_submit() returned %d", ret);
-                op_errno = -ret;
-                goto err;
-        }
-
+    int32_t op_errno = EINVAL;
+    int _fd = -1;
+    struct iobuf *iobuf = NULL;
+    bd_fd_t *bd_fd = NULL;
+    int ret = -1;
+    struct bd_aio_cb *paiocb = NULL;
+    bd_priv_t *priv = NULL;
+    struct iocb *iocb = NULL;
+    bd_attr_t *bdatt = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    priv = this->private;
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd) {
+        STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->readv, fd, size, offset, flags,
+                   xdata);
         return 0;
+    }
+    _fd = bd_fd->fd;
+    bd_inode_ctx_get(fd->inode, this, &bdatt);
+    if (!size) {
+        op_errno = EINVAL;
+        gf_log(this->name, GF_LOG_WARNING, "size=%" GF_PRI_SIZET, size);
+        goto err;
+    }
+
+    iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+    if (!iobuf) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_bd_aio_cb);
+    if (!paiocb) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    paiocb->frame = frame;
+    paiocb->iobuf = iobuf;
+    paiocb->offset = offset;
+    paiocb->op = GF_FOP_READ;
+    paiocb->fd = fd;
+
+    paiocb->iocb.data = paiocb;
+    paiocb->iocb.aio_fildes = _fd;
+    paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD;
+    paiocb->iocb.aio_reqprio = 0;
+    paiocb->iocb.u.c.buf = iobuf_ptr(iobuf);
+    paiocb->iocb.u.c.nbytes = size;
+    paiocb->iocb.u.c.offset = offset;
+
+    iocb = &paiocb->iocb;
+
+    LOCK(&fd->lock);
+    {
+        __bd_fd_set_odirect(fd, bd_fd, flags, offset, size);
+
+        ret = io_submit(priv->ctxp, 1, &iocb);
+    }
+    UNLOCK(&fd->lock);
+
+    if (ret != 1) {
+        gf_log(this->name, GF_LOG_ERROR, "io_submit() returned %d", ret);
+        op_errno = -ret;
+        goto err;
+    }
+
+    return 0;
 err:
-        STACK_UNWIND_STRICT (readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
-        if (iobuf)
-                iobuf_unref (iobuf);
+    STACK_UNWIND_STRICT(readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        if (paiocb)
-                GF_FREE (paiocb);
+    if (paiocb)
+        GF_FREE(paiocb);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_aio_writev_complete (struct bd_aio_cb *paiocb, int res, int res2)
+bd_aio_writev_complete(struct bd_aio_cb *paiocb, int res, int res2)
 {
-        call_frame_t *frame    = NULL;
-        xlator_t     *this     = NULL;
-        struct iatt   prebuf   = {0,};
-        struct iatt   postbuf  = {0,};
-        int           op_ret   = -1;
-        int           op_errno = 0;
-        bd_attr_t    *bdatt    = NULL;
-
-        frame = paiocb->frame;
-        prebuf = paiocb->prebuf;
-        this = frame->this;
-
-        if (res < 0) {
-                op_ret = -1;
-                op_errno = -res;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "writev(async) failed fd=%p,offset=%llu (%d/%s)",
-                        paiocb->fd, (unsigned long long) paiocb->offset, res,
-                        strerror (op_errno));
-
-                goto out;
-        }
-
-        bd_inode_ctx_get (paiocb->fd->inode, this, &bdatt);
-        bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME);
-        memcpy (&postbuf, &bdatt->iatt, sizeof (struct iatt));
-
-        op_ret = res;
-        op_errno = 0;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    struct iatt prebuf = {
+        0,
+    };
+    struct iatt postbuf = {
+        0,
+    };
+    int op_ret = -1;
+    int op_errno = 0;
+    bd_attr_t *bdatt = NULL;
+
+    frame = paiocb->frame;
+    prebuf = paiocb->prebuf;
+    this = frame->this;
+
+    if (res < 0) {
+        op_ret = -1;
+        op_errno = -res;
+        gf_log(this->name, GF_LOG_ERROR,
+               "writev(async) failed fd=%p,offset=%llu (%d/%s)", paiocb->fd,
+               (unsigned long long)paiocb->offset, res, strerror(op_errno));
+
+        goto out;
+    }
+
+    bd_inode_ctx_get(paiocb->fd->inode, this, &bdatt);
+    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
+    memcpy(&postbuf, &bdatt->iatt, sizeof(struct iatt));
+
+    op_ret = res;
+    op_errno = 0;
 
 out:
-        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, &prebuf, &postbuf,
-                             NULL);
+    STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, &prebuf, &postbuf,
+                        NULL);
 
-        if (paiocb->iobref)
-                        iobref_unref (paiocb->iobref);
-        GF_FREE (paiocb);
+    if (paiocb->iobref)
+        iobref_unref(paiocb->iobref);
+    GF_FREE(paiocb);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_aio_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-               struct iovec *iov, int count, off_t offset, uint32_t flags,
-               struct iobref *iobref, dict_t *xdata)
+bd_aio_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *iov,
+              int count, off_t offset, uint32_t flags, struct iobref *iobref,
+              dict_t *xdata)
 {
-        int32_t             op_errno   = EINVAL;
-        int                 _fd        = -1;
-        bd_fd_t            *bd_fd      = NULL;
-        int                 ret        = -1;
-        struct bd_aio_cb   *paiocb     = NULL;
-        bd_priv_t          *priv       = NULL;
-        struct iocb        *iocb       = NULL;
-        bd_attr_t          *bdatt      = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        priv = this->private;
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd) {
-                STACK_WIND (frame, default_writev_cbk,
-                            FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev,
-                            fd, iov, count, offset, flags, iobref, xdata);
-                return 0;
-        }
-
-        bd_inode_ctx_get (fd->inode, this, &bdatt);
-
-        _fd = bd_fd->fd;
-
-        paiocb = GF_CALLOC (1, sizeof (*paiocb), gf_bd_aio_cb);
-        if (!paiocb) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-
-        paiocb->frame = frame;
-        paiocb->offset = offset;
-        paiocb->op = GF_FOP_WRITE;
-        paiocb->fd = fd;
-
-        paiocb->iocb.data = paiocb;
-        paiocb->iocb.aio_fildes = _fd;
-        paiocb->iobref = iobref_ref (iobref);
-        paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV;
-        paiocb->iocb.aio_reqprio = 0;
-        paiocb->iocb.u.v.vec = iov;
-        paiocb->iocb.u.v.nr = count;
-        paiocb->iocb.u.v.offset = offset;
-
-        iocb = &paiocb->iocb;
-
-        memcpy (&paiocb->prebuf, &bdatt->iatt, sizeof (struct iatt));
-        LOCK (&fd->lock);
-        {
-                __bd_fd_set_odirect (fd, bd_fd, flags, offset,
-                                     iov_length (iov, count));
-
-                ret = io_submit (priv->ctxp, 1, &iocb);
-        }
-        UNLOCK (&fd->lock);
-
-        if (ret != 1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "io_submit() returned %d", ret);
-                op_errno = -ret;
-                goto err;
-        }
-
+    int32_t op_errno = EINVAL;
+    int _fd = -1;
+    bd_fd_t *bd_fd = NULL;
+    int ret = -1;
+    struct bd_aio_cb *paiocb = NULL;
+    bd_priv_t *priv = NULL;
+    struct iocb *iocb = NULL;
+    bd_attr_t *bdatt = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    priv = this->private;
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd) {
+        STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->writev, fd, iov, count, offset,
+                   flags, iobref, xdata);
         return 0;
+    }
+
+    bd_inode_ctx_get(fd->inode, this, &bdatt);
+
+    _fd = bd_fd->fd;
+
+    paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_bd_aio_cb);
+    if (!paiocb) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    paiocb->frame = frame;
+    paiocb->offset = offset;
+    paiocb->op = GF_FOP_WRITE;
+    paiocb->fd = fd;
+
+    paiocb->iocb.data = paiocb;
+    paiocb->iocb.aio_fildes = _fd;
+    paiocb->iobref = iobref_ref(iobref);
+    paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV;
+    paiocb->iocb.aio_reqprio = 0;
+    paiocb->iocb.u.v.vec = iov;
+    paiocb->iocb.u.v.nr = count;
+    paiocb->iocb.u.v.offset = offset;
+
+    iocb = &paiocb->iocb;
+
+    memcpy(&paiocb->prebuf, &bdatt->iatt, sizeof(struct iatt));
+    LOCK(&fd->lock);
+    {
+        __bd_fd_set_odirect(fd, bd_fd, flags, offset, iov_length(iov, count));
+
+        ret = io_submit(priv->ctxp, 1, &iocb);
+    }
+    UNLOCK(&fd->lock);
+
+    if (ret != 1) {
+        gf_log(this->name, GF_LOG_ERROR, "io_submit() returned %d", ret);
+        op_errno = -ret;
+        goto err;
+    }
+
+    return 0;
 err:
-        STACK_UNWIND_STRICT (writev, frame, -1, op_errno, 0, 0, 0);
+    STACK_UNWIND_STRICT(writev, frame, -1, op_errno, 0, 0, 0);
 
-        if (paiocb) {
-                if (paiocb->iobref)
-                        iobref_unref (paiocb->iobref);
-                GF_FREE (paiocb);
-        }
+    if (paiocb) {
+        if (paiocb->iobref)
+            iobref_unref(paiocb->iobref);
+        GF_FREE(paiocb);
+    }
 
-        return 0;
+    return 0;
 }
 
 void *
-bd_aio_thread (void *data)
+bd_aio_thread(void *data)
 {
-        xlator_t           *this = NULL;
-        bd_priv_t          *priv = NULL;
-        int                 ret = 0;
-        int                 i = 0;
-        struct io_event    *event = NULL;
-        struct bd_aio_cb   *paiocb = NULL;
-        struct io_event     events[BD_AIO_MAX_NR_GETEVENTS];
-        struct timespec     ts = {0, };
-
-        this = data;
-        THIS = this;
-        priv = this->private;
-
-        ts.tv_sec = 5;
-        for (;;) {
-                memset (&events[0], 0, sizeof (events));
-                ret = io_getevents (priv->ctxp, 1, BD_AIO_MAX_NR_GETEVENTS,
-                                    &events[0], &ts);
-                if (ret < 0) {
-                        if (ret == -EINTR)
-                                continue;
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "io_getevents() returned %d, exiting", ret);
-                        break;
-                }
-
-                for (i = 0; i < ret; i++) {
-                        event = &events[i];
-
-                        paiocb = event->data;
-
-                        switch (paiocb->op) {
-                        case GF_FOP_READ:
-                                bd_aio_readv_complete (paiocb, event->res,
-                                                          event->res2);
-                                break;
-                        case GF_FOP_WRITE:
-                                bd_aio_writev_complete (paiocb, event->res,
-                                                           event->res2);
-                                break;
-                        default:
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "unknown op %d found in piocb",
-                                        paiocb->op);
-                                break;
-                        }
-                }
+    xlator_t *this = NULL;
+    bd_priv_t *priv = NULL;
+    int ret = 0;
+    int i = 0;
+    struct io_event *event = NULL;
+    struct bd_aio_cb *paiocb = NULL;
+    struct io_event events[BD_AIO_MAX_NR_GETEVENTS];
+    struct timespec ts = {
+        0,
+    };
+
+    this = data;
+    THIS = this;
+    priv = this->private;
+
+    ts.tv_sec = 5;
+    for (;;) {
+        memset(&events[0], 0, sizeof(events));
+        ret = io_getevents(priv->ctxp, 1, BD_AIO_MAX_NR_GETEVENTS, &events[0],
+                           &ts);
+        if (ret < 0) {
+            if (ret == -EINTR)
+                continue;
+            gf_log(this->name, GF_LOG_ERROR,
+                   "io_getevents() returned %d, exiting", ret);
+            break;
         }
 
-        return NULL;
+        for (i = 0; i < ret; i++) {
+            event = &events[i];
+
+            paiocb = event->data;
+
+            switch (paiocb->op) {
+                case GF_FOP_READ:
+                    bd_aio_readv_complete(paiocb, event->res, event->res2);
+                    break;
+                case GF_FOP_WRITE:
+                    bd_aio_writev_complete(paiocb, event->res, event->res2);
+                    break;
+                default:
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "unknown op %d found in piocb", paiocb->op);
+                    break;
+            }
+        }
+    }
+
+    return NULL;
 }
 
 int
-bd_aio_init (xlator_t *this)
+bd_aio_init(xlator_t *this)
 {
-        bd_priv_t *priv = NULL;
-        int        ret = 0;
-
-        priv = this->private;
-
-        ret = io_setup (BD_AIO_MAX_NR_EVENTS, &priv->ctxp);
-        if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Linux AIO not available at run-time."
-                        " Continuing with synchronous IO");
-                ret = 0;
-                goto out;
-        }
-
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "io_setup() failed. ret=%d, errno=%d",
-                        ret, errno);
-                goto out;
-        }
-
-        ret = gf_thread_create (&priv->aiothread, NULL,
-                                bd_aio_thread, this, "bdaio");
-        if (ret != 0) {
-                io_destroy (priv->ctxp);
-                goto out;
-        }
-
-        this->fops->readv  = bd_aio_readv;
-        this->fops->writev = bd_aio_writev;
+    bd_priv_t *priv = NULL;
+    int ret = 0;
+
+    priv = this->private;
+
+    ret = io_setup(BD_AIO_MAX_NR_EVENTS, &priv->ctxp);
+    if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "Linux AIO not available at run-time."
+               " Continuing with synchronous IO");
+        ret = 0;
+        goto out;
+    }
+
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "io_setup() failed. ret=%d, errno=%d", ret, errno);
+        goto out;
+    }
+
+    ret = gf_thread_create(&priv->aiothread, NULL, bd_aio_thread, this,
+                           "bdaio");
+    if (ret != 0) {
+        io_destroy(priv->ctxp);
+        goto out;
+    }
+
+    this->fops->readv = bd_aio_readv;
+    this->fops->writev = bd_aio_writev;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-bd_aio_on (xlator_t *this)
+bd_aio_on(xlator_t *this)
 {
-        bd_priv_t *priv = NULL;
-        int        ret = 0;
-
-        priv = this->private;
-
-        if (!priv->aio_init_done) {
-                ret = bd_aio_init (this);
-                if (ret == 0)
-                        priv->aio_capable = _gf_true;
-                else
-                        priv->aio_capable = _gf_false;
-                priv->aio_init_done = _gf_true;
-        }
-
-        if (priv->aio_capable) {
-                this->fops->readv  = bd_aio_readv;
-                this->fops->writev = bd_aio_writev;
-        }
+    bd_priv_t *priv = NULL;
+    int ret = 0;
+
+    priv = this->private;
+
+    if (!priv->aio_init_done) {
+        ret = bd_aio_init(this);
+        if (ret == 0)
+            priv->aio_capable = _gf_true;
+        else
+            priv->aio_capable = _gf_false;
+        priv->aio_init_done = _gf_true;
+    }
+
+    if (priv->aio_capable) {
+        this->fops->readv = bd_aio_readv;
+        this->fops->writev = bd_aio_writev;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-bd_aio_off (xlator_t *this)
+bd_aio_off(xlator_t *this)
 {
-        this->fops->readv  = bd_readv;
-        this->fops->writev = bd_writev;
+    this->fops->readv = bd_readv;
+    this->fops->writev = bd_writev;
 
-        return 0;
+    return 0;
 }
 
 #else
 
 int
-bd_aio_on (xlator_t *this)
+bd_aio_on(xlator_t *this)
 {
-        gf_log (this->name, GF_LOG_INFO,
-                "Linux AIO not available at build-time."
-                " Continuing with synchronous IO");
-        return 0;
+    gf_log(this->name, GF_LOG_INFO,
+           "Linux AIO not available at build-time."
+           " Continuing with synchronous IO");
+    return 0;
 }
 
 int
-bd_aio_off (xlator_t *this)
+bd_aio_off(xlator_t *this)
 {
-        gf_log (this->name, GF_LOG_INFO,
-                "Linux AIO not available at build-time."
-                " Continuing with synchronous IO");
-        return 0;
+    gf_log(this->name, GF_LOG_INFO,
+           "Linux AIO not available at build-time."
+           " Continuing with synchronous IO");
+    return 0;
 }
 
 void
-__bd_fd_set_odirect (fd_t *fd, struct bd_fd *pfd, int opflags,
-                        off_t offset, size_t size)
+__bd_fd_set_odirect(fd_t *fd, struct bd_fd *pfd, int opflags, off_t offset,
+                    size_t size)
 {
-        xlator_t        *this = THIS;
-        gf_log (this->name, GF_LOG_INFO,
-                "Linux AIO not available at build-time."
-                " Continuing with synchronous IO");
-        return;
+    xlator_t *this = THIS;
+    gf_log(this->name, GF_LOG_INFO,
+           "Linux AIO not available at build-time."
+           " Continuing with synchronous IO");
+    return;
 }
 #endif
diff --git a/xlators/storage/bd/src/bd-helper.c b/xlators/storage/bd/src/bd-helper.c
index b2bcf0609da..895c6500acf 100644
--- a/xlators/storage/bd/src/bd-helper.c
+++ b/xlators/storage/bd/src/bd-helper.c
@@ -11,65 +11,65 @@
 #include "syscall.h"
 
 int
-bd_inode_ctx_set (inode_t *inode, xlator_t *this, bd_attr_t *ctx)
+bd_inode_ctx_set(inode_t *inode, xlator_t *this, bd_attr_t *ctx)
 {
-        int       ret  = -1;
-        uint64_t  ctx_int = 0;
+    int ret = -1;
+    uint64_t ctx_int = 0;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
-        GF_VALIDATE_OR_GOTO (this->name, ctx, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, ctx, out);
 
-        ctx_int = (long)ctx;
-        ret = inode_ctx_set (inode, this, &ctx_int);
+    ctx_int = (long)ctx;
+    ret = inode_ctx_set(inode, this, &ctx_int);
 out:
-        return ret;
+    return ret;
 }
 
 int
-bd_inode_ctx_get (inode_t *inode, xlator_t *this, bd_attr_t **ctx)
+bd_inode_ctx_get(inode_t *inode, xlator_t *this, bd_attr_t **ctx)
 {
-        int       ret     = -1;
-        uint64_t  ctx_int = 0;
-
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
-        ret = inode_ctx_get (inode, this, &ctx_int);
-        if (ret)
-                return ret;
-        if (ctx)
-                *ctx = (bd_attr_t *) ctx_int;
-out:
+    int ret = -1;
+    uint64_t ctx_int = 0;
+
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+    ret = inode_ctx_get(inode, this, &ctx_int);
+    if (ret)
         return ret;
+    if (ctx)
+        *ctx = (bd_attr_t *)ctx_int;
+out:
+    return ret;
 }
 
 void
-bd_local_free (xlator_t *this, bd_local_t *local)
+bd_local_free(xlator_t *this, bd_local_t *local)
 {
-        if (!local)
-                return;
-        if (local->fd)
-                fd_unref (local->fd);
-        else if (local->loc.path)
-                loc_wipe (&local->loc);
-        if (local->dict)
-                dict_unref (local->dict);
-        if (local->inode)
-                inode_unref (local->inode);
-        if (local->bdatt) {
-                GF_FREE (local->bdatt->type);
-                GF_FREE (local->bdatt);
-        }
-        mem_put (local);
-        local = NULL;
+    if (!local)
+        return;
+    if (local->fd)
+        fd_unref(local->fd);
+    else if (local->loc.path)
+        loc_wipe(&local->loc);
+    if (local->dict)
+        dict_unref(local->dict);
+    if (local->inode)
+        inode_unref(local->inode);
+    if (local->bdatt) {
+        GF_FREE(local->bdatt->type);
+        GF_FREE(local->bdatt);
+    }
+    mem_put(local);
+    local = NULL;
 }
 
 bd_local_t *
-bd_local_init (call_frame_t *frame, xlator_t *this)
+bd_local_init(call_frame_t *frame, xlator_t *this)
 {
-        frame->local = mem_get0 (this->local_pool);
-        if (!frame->local)
-                return NULL;
+    frame->local = mem_get0(this->local_pool);
+    if (!frame->local)
+        return NULL;
 
-        return frame->local;
+    return frame->local;
 }
 
 /*
@@ -77,218 +77,229 @@ bd_local_init (call_frame_t *frame, xlator_t *this)
  * This function validates this tag against volume-uuid. Also goes
  * through LV list to find out if a thin-pool is configured or not.
  */
-int bd_scan_vg (xlator_t *this, bd_priv_t *priv)
+int
+bd_scan_vg(xlator_t *this, bd_priv_t *priv)
 {
-        vg_t                   brick      = NULL;
-        data_t                *tmp_data   = NULL;
-        struct dm_list        *tags       = NULL;
-        int                    op_ret     = -1;
-        uuid_t                 dict_uuid  = {0, };
-        uuid_t                 vg_uuid    = {0, };
-        gf_boolean_t           uuid       = _gf_false;
-        lvm_str_list_t        *strl       = NULL;
-        struct dm_list        *lv_dm_list = NULL;
-        lv_list_t             *lv_list    = NULL;
-        struct dm_list        *dm_seglist = NULL;
-        lvseg_list_t          *seglist    = NULL;
-        lvm_property_value_t   prop       = {0, };
-        gf_boolean_t           thin       = _gf_false;
-        const char            *lv_name    = NULL;
-
-        brick = lvm_vg_open (priv->handle, priv->vg, "w", 0);
-        if (!brick) {
-                gf_log (this->name, GF_LOG_CRITICAL, "VG %s is not found",
-                        priv->vg);
-                return ENOENT;
-        }
-
-        lv_dm_list = lvm_vg_list_lvs (brick);
-        if (!lv_dm_list)
-                goto check;
-
-        dm_list_iterate_items (lv_list, lv_dm_list) {
-                dm_seglist = lvm_lv_list_lvsegs (lv_list->lv);
-                if (!dm_seglist)
-                        continue;
-                dm_list_iterate_items (seglist, dm_seglist) {
-                        prop = lvm_lvseg_get_property (seglist->lvseg,
-                                                       "segtype");
-                        if (!prop.is_valid || !prop.value.string)
-                                continue;
-                        if (!strcmp (prop.value.string, "thin-pool")) {
-                                thin = _gf_true;
-                                lv_name = lvm_lv_get_name (lv_list->lv);
-                                priv->pool = gf_strdup (lv_name);
-                                gf_log (THIS->name, GF_LOG_INFO, "Thin Pool "
-                                        "\"%s\" will be used for thin LVs",
-                                        lv_name);
-                                break;
-                        }
-                }
+    vg_t brick = NULL;
+    data_t *tmp_data = NULL;
+    struct dm_list *tags = NULL;
+    int op_ret = -1;
+    uuid_t dict_uuid = {
+        0,
+    };
+    uuid_t vg_uuid = {
+        0,
+    };
+    gf_boolean_t uuid = _gf_false;
+    lvm_str_list_t *strl = NULL;
+    struct dm_list *lv_dm_list = NULL;
+    lv_list_t *lv_list = NULL;
+    struct dm_list *dm_seglist = NULL;
+    lvseg_list_t *seglist = NULL;
+    lvm_property_value_t prop = {
+        0,
+    };
+    gf_boolean_t thin = _gf_false;
+    const char *lv_name = NULL;
+
+    brick = lvm_vg_open(priv->handle, priv->vg, "w", 0);
+    if (!brick) {
+        gf_log(this->name, GF_LOG_CRITICAL, "VG %s is not found", priv->vg);
+        return ENOENT;
+    }
+
+    lv_dm_list = lvm_vg_list_lvs(brick);
+    if (!lv_dm_list)
+        goto check;
+
+    dm_list_iterate_items(lv_list, lv_dm_list)
+    {
+        dm_seglist = lvm_lv_list_lvsegs(lv_list->lv);
+        if (!dm_seglist)
+            continue;
+        dm_list_iterate_items(seglist, dm_seglist)
+        {
+            prop = lvm_lvseg_get_property(seglist->lvseg, "segtype");
+            if (!prop.is_valid || !prop.value.string)
+                continue;
+            if (!strcmp(prop.value.string, "thin-pool")) {
+                thin = _gf_true;
+                lv_name = lvm_lv_get_name(lv_list->lv);
+                priv->pool = gf_strdup(lv_name);
+                gf_log(THIS->name, GF_LOG_INFO,
+                       "Thin Pool "
+                       "\"%s\" will be used for thin LVs",
+                       lv_name);
+                break;
+            }
         }
+    }
 
 check:
-        /* If there is no volume-id set in dict, we can't validate */
-        tmp_data = dict_get (this->options, "volume-id");
-        if (!tmp_data) {
-                op_ret = 0;
-                goto out;
-        }
-
-        op_ret = gf_uuid_parse (tmp_data->data, dict_uuid);
-        if (op_ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "wrong volume-id (%s) set in volume file",
-                        tmp_data->data);
-                op_ret = -1;
-                goto out;
-        }
-
-        tags = lvm_vg_get_tags (brick);
-        if (!tags) { /* no tags in the VG */
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Extended attribute trusted.glusterfs."
-                        "volume-id is absent");
-                op_ret = -1;
-                goto out;
-        }
-        dm_list_iterate_items (strl, tags) {
-                if (!strncmp (strl->str, GF_XATTR_VOL_ID_KEY,
-                              SLEN (GF_XATTR_VOL_ID_KEY))) {
-                        uuid = _gf_true;
-                        break;
-                }
-        }
-        /* UUID tag is not set in VG */
-        if (!uuid) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Extended attribute trusted.glusterfs."
-                        "volume-id is absent");
-                op_ret = -1;
-                goto out;
-        }
-
-        op_ret = gf_uuid_parse (strl->str + SLEN (GF_XATTR_VOL_ID_KEY) + 1,
-                             vg_uuid);
-        if (op_ret < 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "wrong volume-id (%s) set in VG", strl->str);
-                        op_ret = -1;
-                        goto out;
-        }
-        if (gf_uuid_compare (dict_uuid, vg_uuid)) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "mismatching volume-id (%s) received. "
-                        "already is a part of volume %s ",
-                        tmp_data->data, vg_uuid);
-                op_ret = -1;
-                goto out;
-        }
-
+    /* If there is no volume-id set in dict, we can't validate */
+    tmp_data = dict_get(this->options, "volume-id");
+    if (!tmp_data) {
         op_ret = 0;
+        goto out;
+    }
+
+    op_ret = gf_uuid_parse(tmp_data->data, dict_uuid);
+    if (op_ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "wrong volume-id (%s) set in volume file", tmp_data->data);
+        op_ret = -1;
+        goto out;
+    }
+
+    tags = lvm_vg_get_tags(brick);
+    if (!tags) { /* no tags in the VG */
+        gf_log(this->name, GF_LOG_ERROR,
+               "Extended attribute trusted.glusterfs."
+               "volume-id is absent");
+        op_ret = -1;
+        goto out;
+    }
+    dm_list_iterate_items(strl, tags)
+    {
+        if (!strncmp(strl->str, GF_XATTR_VOL_ID_KEY,
+                     SLEN(GF_XATTR_VOL_ID_KEY))) {
+            uuid = _gf_true;
+            break;
+        }
+    }
+    /* UUID tag is not set in VG */
+    if (!uuid) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Extended attribute trusted.glusterfs."
+               "volume-id is absent");
+        op_ret = -1;
+        goto out;
+    }
+
+    op_ret = gf_uuid_parse(strl->str + SLEN(GF_XATTR_VOL_ID_KEY) + 1, vg_uuid);
+    if (op_ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR, "wrong volume-id (%s) set in VG",
+               strl->str);
+        op_ret = -1;
+        goto out;
+    }
+    if (gf_uuid_compare(dict_uuid, vg_uuid)) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "mismatching volume-id (%s) received. "
+               "already is a part of volume %s ",
+               tmp_data->data, vg_uuid);
+        op_ret = -1;
+        goto out;
+    }
+
+    op_ret = 0;
 
 out:
-        lvm_vg_close (brick);
+    lvm_vg_close(brick);
 
-        if (!thin)
-                gf_log (THIS->name, GF_LOG_WARNING, "No thin pool found in "
-                        "VG %s\n", priv->vg);
-        else
-                priv->caps |= BD_CAPS_THIN;
+    if (!thin)
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "No thin pool found in "
+               "VG %s\n",
+               priv->vg);
+    else
+        priv->caps |= BD_CAPS_THIN;
 
-        return op_ret;
+    return op_ret;
 }
 
 /* FIXME: Move this code to common place, so posix and bd xlator can use */
 char *
-page_aligned_alloc (size_t size, char **aligned_buf)
+page_aligned_alloc(size_t size, char **aligned_buf)
 {
-        char    *alloc_buf = NULL;
-        char    *buf       = NULL;
+    char *alloc_buf = NULL;
+    char *buf = NULL;
 
-        alloc_buf = GF_CALLOC (1, (size + ALIGN_SIZE), gf_common_mt_char);
-        if (!alloc_buf)
-                return NULL;
-        /* page aligned buffer */
-        buf = GF_ALIGN_BUF (alloc_buf, ALIGN_SIZE);
-        *aligned_buf = buf;
+    alloc_buf = GF_CALLOC(1, (size + ALIGN_SIZE), gf_common_mt_char);
+    if (!alloc_buf)
+        return NULL;
+    /* page aligned buffer */
+    buf = GF_ALIGN_BUF(alloc_buf, ALIGN_SIZE);
+    *aligned_buf = buf;
 
-        return alloc_buf;
+    return alloc_buf;
 }
 
 static int
-__bd_fd_ctx_get (xlator_t *this, fd_t *fd, bd_fd_t **bdfd_p)
+__bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd_p)
 {
-        int         ret      = -1;
-        int         _fd      = -1;
-        char       *devpath  = NULL;
-        bd_fd_t    *bdfd     = NULL;
-        uint64_t    tmp_bdfd = 0;
-        bd_priv_t  *priv     = this->private;
-        bd_gfid_t   gfid     = {0, };
-        bd_attr_t  *bdatt    = NULL;
-
-        /* not bd file */
-        if (fd->inode->ia_type != IA_IFREG ||
-            bd_inode_ctx_get (fd->inode, this, &bdatt))
-                return 0;
-
-        ret = __fd_ctx_get (fd, this, &tmp_bdfd);
-        if (ret == 0) {
-                bdfd = (void *)(long) tmp_bdfd;
-                *bdfd_p = bdfd;
-                return 0;
-        }
-
-        uuid_utoa_r (fd->inode->gfid, gfid);
-        gf_asprintf (&devpath, "/dev/%s/%s", priv->vg, gfid);
-        if (!devpath)
-                goto out;
-
-        _fd = open (devpath, O_RDWR | O_LARGEFILE, 0);
-        if (_fd < 0) {
-                ret = errno;
-                gf_log (this->name, GF_LOG_ERROR, "open on %s: %s", devpath,
-                        strerror (ret));
-                goto out;
-        }
-        bdfd = GF_CALLOC (1, sizeof(bd_fd_t), gf_bd_fd);
-        BD_VALIDATE_MEM_ALLOC (bdfd, ret, out);
-
-        bdfd->fd = _fd;
-        bdfd->flag = O_RDWR | O_LARGEFILE;
-        if (__fd_ctx_set (fd, this, (uint64_t)(long)bdfd) < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set the fd context fd=%p", fd);
-                goto out;
-        }
+    int ret = -1;
+    int _fd = -1;
+    char *devpath = NULL;
+    bd_fd_t *bdfd = NULL;
+    uint64_t tmp_bdfd = 0;
+    bd_priv_t *priv = this->private;
+    bd_gfid_t gfid = {
+        0,
+    };
+    bd_attr_t *bdatt = NULL;
+
+    /* not bd file */
+    if (fd->inode->ia_type != IA_IFREG ||
+        bd_inode_ctx_get(fd->inode, this, &bdatt))
+        return 0;
 
+    ret = __fd_ctx_get(fd, this, &tmp_bdfd);
+    if (ret == 0) {
+        bdfd = (void *)(long)tmp_bdfd;
         *bdfd_p = bdfd;
-
-        ret = 0;
+        return 0;
+    }
+
+    uuid_utoa_r(fd->inode->gfid, gfid);
+    gf_asprintf(&devpath, "/dev/%s/%s", priv->vg, gfid);
+    if (!devpath)
+        goto out;
+
+    _fd = open(devpath, O_RDWR | O_LARGEFILE, 0);
+    if (_fd < 0) {
+        ret = errno;
+        gf_log(this->name, GF_LOG_ERROR, "open on %s: %s", devpath,
+               strerror(ret));
+        goto out;
+    }
+    bdfd = GF_CALLOC(1, sizeof(bd_fd_t), gf_bd_fd);
+    BD_VALIDATE_MEM_ALLOC(bdfd, ret, out);
+
+    bdfd->fd = _fd;
+    bdfd->flag = O_RDWR | O_LARGEFILE;
+    if (__fd_ctx_set(fd, this, (uint64_t)(long)bdfd) < 0) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set the fd context fd=%p",
+               fd);
+        goto out;
+    }
+
+    *bdfd_p = bdfd;
+
+    ret = 0;
 out:
-        GF_FREE (devpath);
-        if (ret) {
-                if (_fd >= 0)
-                        sys_close (_fd);
-                GF_FREE (bdfd);
-        }
-        return ret;
+    GF_FREE(devpath);
+    if (ret) {
+        if (_fd >= 0)
+            sys_close(_fd);
+        GF_FREE(bdfd);
+    }
+    return ret;
 }
 
 int
-bd_fd_ctx_get (xlator_t *this, fd_t *fd, bd_fd_t **bdfd)
+bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd)
 {
-        int   ret;
+    int ret;
 
-        /* FIXME: Is it ok to fd->lock here ? */
-        LOCK (&fd->lock);
-        {
-                ret = __bd_fd_ctx_get (this, fd, bdfd);
-        }
-        UNLOCK (&fd->lock);
+    /* FIXME: Is it ok to fd->lock here ? */
+    LOCK(&fd->lock);
+    {
+        ret = __bd_fd_ctx_get(this, fd, bdfd);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
 /*
@@ -299,579 +310,606 @@ bd_fd_ctx_get (xlator_t *this, fd_t *fd, bd_fd_t **bdfd)
  * size
  */
 int
-bd_validate_bd_xattr (xlator_t *this, char *bd, char **type,
-                      uint64_t *lv_size, uuid_t uuid)
+bd_validate_bd_xattr(xlator_t *this, char *bd, char **type, uint64_t *lv_size,
+                     uuid_t uuid)
 {
-        char       *path  = NULL;
-        int         ret   = -1;
-        bd_gfid_t   gfid  = {0, };
-        bd_priv_t  *priv  = this->private;
-        struct stat stbuf = {0, };
-        uint64_t    size  = 0;
-        vg_t        vg    = NULL;
-        lv_t        lv    = NULL;
-        char     *bytes = NULL;
-
-        bytes = strrchr (bd, ':');
-        if (bytes) {
-                *bytes = '\0';
-                bytes++;
-                gf_string2bytesize (bytes, &size);
-        }
-
-        if (strcmp (bd, BD_LV) && strcmp (bd, BD_THIN)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "invalid xattr %s", bd);
-                return -1;
-        }
-        *type = gf_strdup (bd);
-
-        /*
-         * Check if LV really exist, there could be a failure
-         * after setxattr and successful LV creation
-         */
-        uuid_utoa_r (uuid, gfid);
-        gf_asprintf (&path, "/dev/%s/%s", priv->vg, gfid);
-        if (!path) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "insufficient memory");
-                return 0;
-        }
-
-        /* Destination file does not exist */
-        if (sys_stat (path, &stbuf)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "lstat failed for path %s", path);
-                GF_FREE (path);
-                return -1;
-        }
-
-        vg = lvm_vg_open (priv->handle, priv->vg, "r", 0);
-        if (!vg) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "VG %s does not exist?", priv->vg);
-                ret = -1;
-                goto out;
-        }
-
-        lv = lvm_lv_from_name (vg, gfid);
-        if (!lv) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "LV %s does not exist", gfid);
-                ret = -1;
-                goto out;
-        }
-
-        *lv_size = lvm_lv_get_size (lv);
-        if (size == *lv_size) {
-                ret = 0;
-                goto out;
-        }
+    char *path = NULL;
+    int ret = -1;
+    bd_gfid_t gfid = {
+        0,
+    };
+    bd_priv_t *priv = this->private;
+    struct stat stbuf = {
+        0,
+    };
+    uint64_t size = 0;
+    vg_t vg = NULL;
+    lv_t lv = NULL;
+    char *bytes = NULL;
+
+    bytes = strrchr(bd, ':');
+    if (bytes) {
+        *bytes = '\0';
+        bytes++;
+        gf_string2bytesize(bytes, &size);
+    }
+
+    if (strcmp(bd, BD_LV) && strcmp(bd, BD_THIN)) {
+        gf_log(this->name, GF_LOG_WARNING, "invalid xattr %s", bd);
+        return -1;
+    }
+    *type = gf_strdup(bd);
+
+    /*
+     * Check if LV really exist, there could be a failure
+     * after setxattr and successful LV creation
+     */
+    uuid_utoa_r(uuid, gfid);
+    gf_asprintf(&path, "/dev/%s/%s", priv->vg, gfid);
+    if (!path) {
+        gf_log(this->name, GF_LOG_WARNING, "insufficient memory");
+        return 0;
+    }
+
+    /* Destination file does not exist */
+    if (sys_stat(path, &stbuf)) {
+        gf_log(this->name, GF_LOG_WARNING, "lstat failed for path %s", path);
+        GF_FREE(path);
+        return -1;
+    }
+
+    vg = lvm_vg_open(priv->handle, priv->vg, "r", 0);
+    if (!vg) {
+        gf_log(this->name, GF_LOG_WARNING, "VG %s does not exist?", priv->vg);
+        ret = -1;
+        goto out;
+    }
+
+    lv = lvm_lv_from_name(vg, gfid);
+    if (!lv) {
+        gf_log(this->name, GF_LOG_WARNING, "LV %s does not exist", gfid);
+        ret = -1;
+        goto out;
+    }
+
+    *lv_size = lvm_lv_get_size(lv);
+    if (size == *lv_size) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = 1;
+    ret = 1;
 
 out:
-        if (vg)
-                lvm_vg_close (vg);
+    if (vg)
+        lvm_vg_close(vg);
 
-        GF_FREE (path);
-        return ret;
+    GF_FREE(path);
+    return ret;
 }
 
 static int
-create_thin_lv (char *vg, char *pool, char *lv, uint64_t extent)
+create_thin_lv(char *vg, char *pool, char *lv, uint64_t extent)
 {
-        int         ret    = -1;
-        runner_t    runner = {0, };
-        char       *path   = NULL;
-        struct stat stat   = {0, };
-
-        runinit (&runner);
-        runner_add_args  (&runner, LVM_CREATE, NULL);
-        runner_add_args  (&runner, "--thin", NULL);
-        runner_argprintf (&runner, "%s/%s", vg, pool);
-        runner_add_args  (&runner, "--name", NULL);
-        runner_argprintf (&runner, "%s", lv);
-        runner_add_args  (&runner, "--virtualsize", NULL);
-        runner_argprintf (&runner, "%ldB", extent);
-        runner_start (&runner);
-        runner_end (&runner);
-
-        gf_asprintf (&path, "/dev/%s/%s", vg, lv);
-        if (!path) {
-                ret = ENOMEM;
-                goto out;
-        }
-        if (sys_lstat (path, &stat) < 0)
-                ret = EAGAIN;
-        else
-                ret = 0;
+    int ret = -1;
+    runner_t runner = {
+        0,
+    };
+    char *path = NULL;
+    struct stat stat = {
+        0,
+    };
+
+    runinit(&runner);
+    runner_add_args(&runner, LVM_CREATE, NULL);
+    runner_add_args(&runner, "--thin", NULL);
+    runner_argprintf(&runner, "%s/%s", vg, pool);
+    runner_add_args(&runner, "--name", NULL);
+    runner_argprintf(&runner, "%s", lv);
+    runner_add_args(&runner, "--virtualsize", NULL);
+    runner_argprintf(&runner, "%ldB", extent);
+    runner_start(&runner);
+    runner_end(&runner);
+
+    gf_asprintf(&path, "/dev/%s/%s", vg, lv);
+    if (!path) {
+        ret = ENOMEM;
+        goto out;
+    }
+    if (sys_lstat(path, &stat) < 0)
+        ret = EAGAIN;
+    else
+        ret = 0;
 out:
-        GF_FREE (path);
-        return ret;
+    GF_FREE(path);
+    return ret;
 }
 
 int
-bd_create (uuid_t uuid, uint64_t size, char *type, bd_priv_t *priv)
+bd_create(uuid_t uuid, uint64_t size, char *type, bd_priv_t *priv)
 {
-        int       ret  = 0;
-        vg_t      vg   = NULL;
-        bd_gfid_t gfid = {0, };
+    int ret = 0;
+    vg_t vg = NULL;
+    bd_gfid_t gfid = {
+        0,
+    };
 
-        uuid_utoa_r (uuid, gfid);
+    uuid_utoa_r(uuid, gfid);
 
-        if (!strcmp (type, BD_THIN))
-                return create_thin_lv (priv->vg, priv->pool, gfid,
-                                       size);
+    if (!strcmp(type, BD_THIN))
+        return create_thin_lv(priv->vg, priv->pool, gfid, size);
 
-        vg = lvm_vg_open (priv->handle, priv->vg,  "w", 0);
-        if (!vg) {
-                gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed",
-                        priv->vg);
-                return ENOENT;
-        }
+    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
+    if (!vg) {
+        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
+        return ENOENT;
+    }
 
-        if (!lvm_vg_create_lv_linear (vg, gfid, size)) {
-                gf_log (THIS->name, GF_LOG_WARNING, "lvm_vg_create_lv_linear "
-                        "failed");
-                ret = errno;
-        }
+    if (!lvm_vg_create_lv_linear(vg, gfid, size)) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "lvm_vg_create_lv_linear "
+               "failed");
+        ret = errno;
+    }
 
-        lvm_vg_close (vg);
+    lvm_vg_close(vg);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-bd_resize (bd_priv_t *priv, uuid_t uuid, size_t size)
+bd_resize(bd_priv_t *priv, uuid_t uuid, size_t size)
 {
-        uint64_t        new_size  = 0;
-        runner_t        runner    = {0, };
-        bd_gfid_t       gfid      = {0, };
-        int             ret       = 0;
-        vg_t            vg        = NULL;
-        lv_t            lv        = NULL;
-
-        uuid_utoa_r (uuid, gfid);
-
-        runinit (&runner);
-
-        runner_add_args  (&runner, LVM_RESIZE, NULL);
-        runner_argprintf (&runner, "%s/%s", priv->vg, gfid);
-        runner_argprintf (&runner, "-L%ldb", size);
-        runner_add_args  (&runner, "-f", NULL);
-
-        runner_start (&runner);
-        runner_end (&runner);
-
-        vg = lvm_vg_open (priv->handle, priv->vg, "w", 0);
-        if (!vg) {
-                gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed",
-                        priv->vg);
-                return EAGAIN;
-        }
-
-        lv = lvm_lv_from_name (vg, gfid);
-        if (!lv) {
-                gf_log (THIS->name, GF_LOG_WARNING, "LV %s not found", gfid);
-                ret = EIO;
-                goto out;
-        }
-        new_size = lvm_lv_get_size (lv);
-
-        if (new_size != size) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "resized LV size %" PRIu64 " does "
-                        "not match requested size %zd", new_size, size);
-                ret = EIO;
-        }
+    uint64_t new_size = 0;
+    runner_t runner = {
+        0,
+    };
+    bd_gfid_t gfid = {
+        0,
+    };
+    int ret = 0;
+    vg_t vg = NULL;
+    lv_t lv = NULL;
+
+    uuid_utoa_r(uuid, gfid);
+
+    runinit(&runner);
+
+    runner_add_args(&runner, LVM_RESIZE, NULL);
+    runner_argprintf(&runner, "%s/%s", priv->vg, gfid);
+    runner_argprintf(&runner, "-L%ldb", size);
+    runner_add_args(&runner, "-f", NULL);
+
+    runner_start(&runner);
+    runner_end(&runner);
+
+    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
+    if (!vg) {
+        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
+        return EAGAIN;
+    }
+
+    lv = lvm_lv_from_name(vg, gfid);
+    if (!lv) {
+        gf_log(THIS->name, GF_LOG_WARNING, "LV %s not found", gfid);
+        ret = EIO;
+        goto out;
+    }
+    new_size = lvm_lv_get_size(lv);
+
+    if (new_size != size) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "resized LV size %" PRIu64
+               " does "
+               "not match requested size %zd",
+               new_size, size);
+        ret = EIO;
+    }
 
 out:
-        lvm_vg_close (vg);
-        return ret;
+    lvm_vg_close(vg);
+    return ret;
 }
 
 uint64_t
-bd_get_default_extent (bd_priv_t *priv)
+bd_get_default_extent(bd_priv_t *priv)
 {
-        vg_t   vg = NULL;
-        uint64_t size = 0;
-
-        vg = lvm_vg_open (priv->handle, priv->vg,  "w", 0);
-        if (!vg) {
-                gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed",
-                        priv->vg);
-                return 0;
-        }
+    vg_t vg = NULL;
+    uint64_t size = 0;
+
+    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
+    if (!vg) {
+        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
+        return 0;
+    }
 
-        size = lvm_vg_get_extent_size (vg);
+    size = lvm_vg_get_extent_size(vg);
 
-        lvm_vg_close (vg);
+    lvm_vg_close(vg);
 
-        return size;
+    return size;
 }
 
 /*
  * Adjusts the user specified size to VG specific extent size
  */
 uint64_t
-bd_adjust_size (bd_priv_t *priv, size_t size)
+bd_adjust_size(bd_priv_t *priv, size_t size)
 {
-        uint64_t extent = 0;
-        uint64_t nr_ex  = 0;
+    uint64_t extent = 0;
+    uint64_t nr_ex = 0;
 
-        extent = bd_get_default_extent (priv);
-        if (!extent)
-                return 0;
+    extent = bd_get_default_extent(priv);
+    if (!extent)
+        return 0;
 
-        nr_ex = size / extent;
-        if (size % extent)
-                nr_ex++;
+    nr_ex = size / extent;
+    if (size % extent)
+        nr_ex++;
 
-        size = extent * nr_ex;
+    size = extent * nr_ex;
 
-        return size;
+    return size;
 }
 
 int
-bd_delete_lv (bd_priv_t *priv, const char *lv_name, int *op_errno)
+bd_delete_lv(bd_priv_t *priv, const char *lv_name, int *op_errno)
 {
-        vg_t    vg  = NULL;
-        lv_t    lv  = NULL;
-        int     ret = -1;
-
-        *op_errno = 0;
-        vg = lvm_vg_open (priv->handle, priv->vg, "w", 0);
-        if (!vg) {
-                gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed",
-                        priv->vg);
-                *op_errno = ENOENT;
-                return -1;
-        }
-        lv = lvm_lv_from_name (vg, lv_name);
-        if (!lv) {
-                gf_log (THIS->name, GF_LOG_WARNING, "No such LV %s", lv_name);
-                *op_errno = ENOENT;
-                goto out;
-        }
-        ret = lvm_vg_remove_lv (lv);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_WARNING, "removing LV %s failed",
-                        lv_name);
-                *op_errno = errno;
-                goto out;
-        }
+    vg_t vg = NULL;
+    lv_t lv = NULL;
+    int ret = -1;
+
+    *op_errno = 0;
+    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
+    if (!vg) {
+        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
+        *op_errno = ENOENT;
+        return -1;
+    }
+    lv = lvm_lv_from_name(vg, lv_name);
+    if (!lv) {
+        gf_log(THIS->name, GF_LOG_WARNING, "No such LV %s", lv_name);
+        *op_errno = ENOENT;
+        goto out;
+    }
+    ret = lvm_vg_remove_lv(lv);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_WARNING, "removing LV %s failed", lv_name);
+        *op_errno = errno;
+        goto out;
+    }
 out:
-        lvm_vg_close (vg);
+    lvm_vg_close(vg);
 
-        return ret;
+    return ret;
 }
 
 void
 bd_update_amtime(struct iatt *iatt, int flag)
 {
-        struct timespec ts = {0, };
-
-        clock_gettime (CLOCK_REALTIME, &ts);
-        if (flag & GF_SET_ATTR_ATIME) {
-                iatt->ia_atime = ts.tv_sec;
-                iatt->ia_atime_nsec = ts.tv_nsec;
-        }
-        if (flag & GF_SET_ATTR_MTIME) {
-                iatt->ia_mtime = ts.tv_sec;
-                iatt->ia_mtime_nsec = ts.tv_nsec;
-        }
+    struct timespec ts = {
+        0,
+    };
+
+    clock_gettime(CLOCK_REALTIME, &ts);
+    if (flag & GF_SET_ATTR_ATIME) {
+        iatt->ia_atime = ts.tv_sec;
+        iatt->ia_atime_nsec = ts.tv_nsec;
+    }
+    if (flag & GF_SET_ATTR_MTIME) {
+        iatt->ia_mtime = ts.tv_sec;
+        iatt->ia_mtime_nsec = ts.tv_nsec;
+    }
 }
 
 int
-bd_snapshot_create (bd_local_t *local, bd_priv_t *priv)
+bd_snapshot_create(bd_local_t *local, bd_priv_t *priv)
 {
-        char       *path   = NULL;
-        bd_gfid_t   dest   = {0, };
-        bd_gfid_t   origin = {0, };
-        int         ret    = 0;
-        runner_t    runner = {0, };
-        struct stat stat   = {0, };
-
-        uuid_utoa_r (local->dloc->gfid, dest);
-        uuid_utoa_r (local->loc.gfid, origin);
-
-        gf_asprintf (&path, "/dev/%s/%s", priv->vg, dest);
-        if (!path) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "Insufficient memory");
-                return ENOMEM;
-        }
-
-        runinit (&runner);
-        runner_add_args  (&runner, LVM_CREATE, NULL);
-        runner_add_args  (&runner, "--snapshot", NULL);
-        runner_argprintf (&runner, "/dev/%s/%s", priv->vg, origin);
-        runner_add_args  (&runner, "--name", NULL);
-        runner_argprintf (&runner, "%s", dest);
-        if (strcmp (local->bdatt->type, BD_THIN))
-                runner_argprintf (&runner, "-L%ldB", local->size);
-        runner_start (&runner);
-        runner_end (&runner);
-
-        if (sys_lstat (path, &stat) < 0)
-                ret = EIO;
-
-        GF_FREE (path);
-        return ret;
+    char *path = NULL;
+    bd_gfid_t dest = {
+        0,
+    };
+    bd_gfid_t origin = {
+        0,
+    };
+    int ret = 0;
+    runner_t runner = {
+        0,
+    };
+    struct stat stat = {
+        0,
+    };
+
+    uuid_utoa_r(local->dloc->gfid, dest);
+    uuid_utoa_r(local->loc.gfid, origin);
+
+    gf_asprintf(&path, "/dev/%s/%s", priv->vg, dest);
+    if (!path) {
+        gf_log(THIS->name, GF_LOG_WARNING, "Insufficient memory");
+        return ENOMEM;
+    }
+
+    runinit(&runner);
+    runner_add_args(&runner, LVM_CREATE, NULL);
+    runner_add_args(&runner, "--snapshot", NULL);
+    runner_argprintf(&runner, "/dev/%s/%s", priv->vg, origin);
+    runner_add_args(&runner, "--name", NULL);
+    runner_argprintf(&runner, "%s", dest);
+    if (strcmp(local->bdatt->type, BD_THIN))
+        runner_argprintf(&runner, "-L%ldB", local->size);
+    runner_start(&runner);
+    runner_end(&runner);
+
+    if (sys_lstat(path, &stat) < 0)
+        ret = EIO;
+
+    GF_FREE(path);
+    return ret;
 }
 
 int
-bd_clone (bd_local_t *local, bd_priv_t *priv)
+bd_clone(bd_local_t *local, bd_priv_t *priv)
 {
-        int           ret          = ENOMEM;
-        int           fd1          = -1;
-        int           fd2          = -1;
-        int           i            = 0;
-        char         *buff         = NULL;
-        ssize_t       bytes        = 0;
-        char         *spath        = NULL;
-        char         *dpath        = NULL;
-        struct iovec *vec          = NULL;
-        bd_gfid_t     source       = {0, };
-        bd_gfid_t     dest         = {0, };
-        void         *bufp[IOV_NR] = {0, };
-
-        vec = GF_CALLOC (IOV_NR, sizeof (struct iovec), gf_common_mt_iovec);
-        if (!vec)
-                return ENOMEM;
-
-        for (i = 0; i < IOV_NR; i++) {
-                bufp[i] = page_aligned_alloc (IOV_SIZE, &buff);
-                if (!buff)
-                        goto out;
-                vec[i].iov_base = buff;
-                vec[i].iov_len = IOV_SIZE;
-        }
-
-        uuid_utoa_r (local->loc.gfid, source);
-        uuid_utoa_r (local->dloc->gfid, dest);
-
-        gf_asprintf (&spath, "/dev/%s/%s", priv->vg, source);
-        gf_asprintf (&dpath, "/dev/%s/%s", priv->vg, dest);
-        if (!spath || !dpath)
-                goto out;
-
-        ret = bd_create (local->dloc->gfid, local->size,
-                         local->bdatt->type,  priv);
-        if (ret)
-                goto out;
-
-        fd1 = open (spath, O_RDONLY | O_DIRECT);
-        if (fd1 < 0) {
-                ret = errno;
-                goto out;
+    int ret = ENOMEM;
+    int fd1 = -1;
+    int fd2 = -1;
+    int i = 0;
+    char *buff = NULL;
+    ssize_t bytes = 0;
+    char *spath = NULL;
+    char *dpath = NULL;
+    struct iovec *vec = NULL;
+    bd_gfid_t source = {
+        0,
+    };
+    bd_gfid_t dest = {
+        0,
+    };
+    void *bufp[IOV_NR] = {
+        0,
+    };
+
+    vec = GF_CALLOC(IOV_NR, sizeof(struct iovec), gf_common_mt_iovec);
+    if (!vec)
+        return ENOMEM;
+
+    for (i = 0; i < IOV_NR; i++) {
+        bufp[i] = page_aligned_alloc(IOV_SIZE, &buff);
+        if (!buff)
+            goto out;
+        vec[i].iov_base = buff;
+        vec[i].iov_len = IOV_SIZE;
+    }
+
+    uuid_utoa_r(local->loc.gfid, source);
+    uuid_utoa_r(local->dloc->gfid, dest);
+
+    gf_asprintf(&spath, "/dev/%s/%s", priv->vg, source);
+    gf_asprintf(&dpath, "/dev/%s/%s", priv->vg, dest);
+    if (!spath || !dpath)
+        goto out;
+
+    ret = bd_create(local->dloc->gfid, local->size, local->bdatt->type, priv);
+    if (ret)
+        goto out;
+
+    fd1 = open(spath, O_RDONLY | O_DIRECT);
+    if (fd1 < 0) {
+        ret = errno;
+        goto out;
+    }
+    fd2 = open(dpath, O_WRONLY | O_DIRECT);
+    if (fd2 < 0) {
+        ret = errno;
+        goto out;
+    }
+
+    while (1) {
+        bytes = sys_readv(fd1, vec, IOV_NR);
+        if (bytes < 0) {
+            ret = errno;
+            gf_log(THIS->name, GF_LOG_WARNING, "read failed: %s",
+                   strerror(ret));
+            goto out;
         }
-        fd2 = open (dpath, O_WRONLY | O_DIRECT);
-        if (fd2 < 0) {
-                ret = errno;
-                goto out;
+        if (!bytes)
+            break;
+        bytes = sys_writev(fd2, vec, IOV_NR);
+        if (bytes < 0) {
+            ret = errno;
+            gf_log(THIS->name, GF_LOG_WARNING, "write failed: %s",
+                   strerror(ret));
+            goto out;
         }
-
-        while (1) {
-                bytes = sys_readv (fd1, vec, IOV_NR);
-                if (bytes < 0) {
-                        ret = errno;
-                        gf_log (THIS->name, GF_LOG_WARNING, "read failed: %s",
-                                strerror (ret));
-                        goto out;
-                }
-                if (!bytes)
-                        break;
-                bytes = sys_writev (fd2, vec, IOV_NR);
-                if (bytes < 0) {
-                        ret = errno;
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "write failed: %s", strerror (ret));
-                        goto out;
-                }
-        }
-        ret = 0;
+    }
+    ret = 0;
 
 out:
-        for (i = 0; i < IOV_NR; i++)
-                GF_FREE (bufp[i]);
-        GF_FREE (vec);
+    for (i = 0; i < IOV_NR; i++)
+        GF_FREE(bufp[i]);
+    GF_FREE(vec);
 
-        if (fd1 != -1)
-                sys_close (fd1);
-        if (fd2 != -1)
-                sys_close (fd2);
+    if (fd1 != -1)
+        sys_close(fd1);
+    if (fd2 != -1)
+        sys_close(fd2);
 
-        GF_FREE (spath);
-        GF_FREE (dpath);
+    GF_FREE(spath);
+    GF_FREE(dpath);
 
-        return ret;
+    return ret;
 }
 
 /*
  * Merges snapshot LV to origin LV and returns status
  */
 int
-bd_merge (bd_priv_t *priv, uuid_t gfid)
+bd_merge(bd_priv_t *priv, uuid_t gfid)
 {
-        bd_gfid_t   dest   = {0, };
-        char       *path   = NULL;
-        struct stat stat   = {0, };
-        runner_t    runner = {0, };
-        int         ret    = 0;
-
-        uuid_utoa_r (gfid, dest);
-        gf_asprintf (&path, "/dev/%s/%s", priv->vg, dest);
-
-        runinit (&runner);
-        runner_add_args (&runner, LVM_CONVERT, NULL);
-        runner_add_args (&runner, "--merge", NULL);
-        runner_argprintf (&runner, "%s", path);
-        runner_start (&runner);
-        runner_end (&runner);
-
-        if (!sys_lstat (path, &stat))
-                ret = EIO;
-
-        GF_FREE (path);
-
-        return ret;
+    bd_gfid_t dest = {
+        0,
+    };
+    char *path = NULL;
+    struct stat stat = {
+        0,
+    };
+    runner_t runner = {
+        0,
+    };
+    int ret = 0;
+
+    uuid_utoa_r(gfid, dest);
+    gf_asprintf(&path, "/dev/%s/%s", priv->vg, dest);
+
+    runinit(&runner);
+    runner_add_args(&runner, LVM_CONVERT, NULL);
+    runner_add_args(&runner, "--merge", NULL);
+    runner_argprintf(&runner, "%s", path);
+    runner_start(&runner);
+    runner_end(&runner);
+
+    if (!sys_lstat(path, &stat))
+        ret = EIO;
+
+    GF_FREE(path);
+
+    return ret;
 }
 
 int
-bd_get_origin (bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict)
+bd_get_origin(bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict)
 {
-        vg_t                      brick      = NULL;
-        lvm_property_value_t      prop       = {0, };
-        lv_t                      lv         = NULL;
-        int                       ret        = -1;
-        bd_gfid_t                 gfid       = {0, };
-        inode_t                  *inode      = NULL;
-        char                     *origin     = NULL;
-
-        brick = lvm_vg_open (priv->handle, priv->vg, "w", 0);
-        if (!brick) {
-                gf_log (THIS->name, GF_LOG_CRITICAL, "VG %s is not found",
-                        priv->vg);
-                return ENOENT;
-        }
-
-        if (fd)
-                inode = fd->inode;
-        else
-                inode = loc->inode;
-
-        uuid_utoa_r (inode->gfid, gfid);
-        lv = lvm_lv_from_name (brick, gfid);
-        if (!lv) {
-                gf_log (THIS->name, GF_LOG_CRITICAL, "LV %s not found", gfid);
-                ret = ENOENT;
-                goto out;
-        }
-
-        prop = lvm_lv_get_property (lv, "origin");
-        if (!prop.is_valid || !prop.value.string) {
-                ret = ENODATA;
-                goto out;
-        }
-
-        origin = gf_strdup (prop.value.string);
-        ret = dict_set_dynstr (dict, BD_ORIGIN, origin);
+    vg_t brick = NULL;
+    lvm_property_value_t prop = {
+        0,
+    };
+    lv_t lv = NULL;
+    int ret = -1;
+    bd_gfid_t gfid = {
+        0,
+    };
+    inode_t *inode = NULL;
+    char *origin = NULL;
+
+    brick = lvm_vg_open(priv->handle, priv->vg, "w", 0);
+    if (!brick) {
+        gf_log(THIS->name, GF_LOG_CRITICAL, "VG %s is not found", priv->vg);
+        return ENOENT;
+    }
+
+    if (fd)
+        inode = fd->inode;
+    else
+        inode = loc->inode;
+
+    uuid_utoa_r(inode->gfid, gfid);
+    lv = lvm_lv_from_name(brick, gfid);
+    if (!lv) {
+        gf_log(THIS->name, GF_LOG_CRITICAL, "LV %s not found", gfid);
+        ret = ENOENT;
+        goto out;
+    }
+
+    prop = lvm_lv_get_property(lv, "origin");
+    if (!prop.is_valid || !prop.value.string) {
+        ret = ENODATA;
+        goto out;
+    }
+
+    origin = gf_strdup(prop.value.string);
+    ret = dict_set_dynstr(dict, BD_ORIGIN, origin);
 
 out:
-        lvm_vg_close (brick);
-        return ret;
+    lvm_vg_close(brick);
+    return ret;
 }
 
 #ifndef BLKZEROOUT
 
 int
-bd_do_manual_zerofill (int fd, off_t offset, off_t len, int o_direct)
+bd_do_manual_zerofill(int fd, off_t offset, off_t len, int o_direct)
 {
-        off_t           num_vect            = 0;
-        off_t           num_loop            = 1;
-        int             idx                 = 0;
-        int             op_ret              = -1;
-        int             vect_size           = IOV_SIZE;
-        off_t           remain              = 0;
-        off_t           extra               = 0;
-        struct iovec   *vector              = NULL;
-        char           *iov_base            = NULL;
-        char           *alloc_buf           = NULL;
-
-        if (len == 0)
-                return 0;
-
-        if (len < IOV_SIZE)
-                vect_size = len;
-
-        num_vect = len / (vect_size);
-        remain = len % vect_size ;
-
-        if (num_vect > MAX_NO_VECT) {
-                extra = num_vect % MAX_NO_VECT;
-                num_loop = num_vect / MAX_NO_VECT;
-                num_vect = MAX_NO_VECT;
-        }
-
-        vector = GF_CALLOC (num_vect, sizeof(struct iovec),
-                             gf_common_mt_iovec);
-        if (!vector)
-                  return -1;
-
-        if (o_direct) {
-                alloc_buf = page_aligned_alloc (vect_size, &iov_base);
-                if (!alloc_buf) {
-                        gf_log ("bd_do_manual_zerofill", GF_LOG_DEBUG,
-                                 "memory alloc failed, vect_size %d: %s",
-                                  vect_size, strerror (errno));
-                        GF_FREE (vector);
-                        return -1;
-                }
-        } else {
-                iov_base = GF_CALLOC (vect_size, sizeof(char),
-                                        gf_common_mt_char);
-                if (!iov_base) {
-                        GF_FREE (vector);
-                        return -1;
-                 }
-        }
-
-        for (idx = 0; idx < num_vect; idx++) {
-                vector[idx].iov_base = iov_base;
-                vector[idx].iov_len  = vect_size;
-        }
-
-        if (sys_lseek (fd, offset, SEEK_SET) < 0) {
-                op_ret = -1;
-                goto err;
-        }
+    off_t num_vect = 0;
+    off_t num_loop = 1;
+    int idx = 0;
+    int op_ret = -1;
+    int vect_size = IOV_SIZE;
+    off_t remain = 0;
+    off_t extra = 0;
+    struct iovec *vector = NULL;
+    char *iov_base = NULL;
+    char *alloc_buf = NULL;
+
+    if (len == 0)
+        return 0;
 
-        for (idx = 0; idx < num_loop; idx++) {
-                op_ret = sys_writev (fd, vector, num_vect);
-                if (op_ret < 0)
-                        goto err;
-        }
-        if (extra) {
-                op_ret = sys_writev (fd, vector, extra);
-                if (op_ret < 0)
-                        goto err;
+    if (len < IOV_SIZE)
+        vect_size = len;
+
+    num_vect = len / (vect_size);
+    remain = len % vect_size;
+
+    if (num_vect > MAX_NO_VECT) {
+        extra = num_vect % MAX_NO_VECT;
+        num_loop = num_vect / MAX_NO_VECT;
+        num_vect = MAX_NO_VECT;
+    }
+
+    vector = GF_CALLOC(num_vect, sizeof(struct iovec), gf_common_mt_iovec);
+    if (!vector)
+        return -1;
+
+    if (o_direct) {
+        alloc_buf = page_aligned_alloc(vect_size, &iov_base);
+        if (!alloc_buf) {
+            gf_log("bd_do_manual_zerofill", GF_LOG_DEBUG,
+                   "memory alloc failed, vect_size %d: %s", vect_size,
+                   strerror(errno));
+            GF_FREE(vector);
+            return -1;
         }
-        if (remain) {
-                vector[0].iov_len = remain;
-                op_ret = sys_writev (fd, vector , 1);
-                if (op_ret < 0)
-                        goto err;
+    } else {
+        iov_base = GF_CALLOC(vect_size, sizeof(char), gf_common_mt_char);
+        if (!iov_base) {
+            GF_FREE(vector);
+            return -1;
         }
-        op_ret = 0;
+    }
+
+    for (idx = 0; idx < num_vect; idx++) {
+        vector[idx].iov_base = iov_base;
+        vector[idx].iov_len = vect_size;
+    }
+
+    if (sys_lseek(fd, offset, SEEK_SET) < 0) {
+        op_ret = -1;
+        goto err;
+    }
+
+    for (idx = 0; idx < num_loop; idx++) {
+        op_ret = sys_writev(fd, vector, num_vect);
+        if (op_ret < 0)
+            goto err;
+    }
+    if (extra) {
+        op_ret = sys_writev(fd, vector, extra);
+        if (op_ret < 0)
+            goto err;
+    }
+    if (remain) {
+        vector[0].iov_len = remain;
+        op_ret = sys_writev(fd, vector, 1);
+        if (op_ret < 0)
+            goto err;
+    }
+    op_ret = 0;
 err:
-        if (o_direct)
-                GF_FREE (alloc_buf);
-        else
-                GF_FREE (iov_base);
-        GF_FREE (vector);
-        return op_ret;
+    if (o_direct)
+        GF_FREE(alloc_buf);
+    else
+        GF_FREE(iov_base);
+    GF_FREE(vector);
+    return op_ret;
 }
 
 #else
@@ -886,145 +924,150 @@ err:
  * /sys/block/<block-device>/queue/write_same_max_bytes
  */
 int
-bd_do_ioctl_zerofill (bd_priv_t *priv, bd_attr_t *bdatt, int fd, char *vg,
-                      off_t offset, off_t len)
+bd_do_ioctl_zerofill(bd_priv_t *priv, bd_attr_t *bdatt, int fd, char *vg,
+                     off_t offset, off_t len)
 {
-        char      *dm           = NULL;
-        char       dmname[4096] = {0, };
-        char       lvname[4096] = {0, };
-        char       sysfs[4096]  = {0, };
-        bd_gfid_t  uuid         = {0, };
-        char      *p            = NULL;
-        off_t      max_bytes    = 0;
-        int        sysfd        = -1;
-        int        ret          = 0;
-        uint64_t   param[2]     = {0, 0};
-        off_t      nr_loop      = 0;
-        char       buff[16]     = {0, };
-
-        uuid_utoa_r (bdatt->iatt.ia_gfid, uuid);
-        sprintf (lvname, "/dev/%s/%s", vg, uuid);
-
-        ret = sys_readlink(lvname, dmname, 4096);
-        if (ret < 0) {
-                gf_log("bd", GF_LOG_DEBUG,
-                       "Failed to read symbolic link '%s': %s",
-                       lvname, strerror(errno));
-                goto skip;
-        }
-
-        dmname[ret] = '\0';
-
-        p = strrchr (dmname, '/');
-        if (p)
-                dm = p + 1;
-        else
-                dm = dmname;
-
-        sprintf(sysfs, "/sys/block/%s/queue/write_same_max_bytes", dm);
-        sysfd = open (sysfs, O_RDONLY);
-        if (sysfd < 0) {
-                gf_log ("bd_do_ioctl_zerofill", GF_LOG_DEBUG,
-                        "sysfs file %s does not exist", lvname);
-                goto skip;
-        }
-
-        sys_read (sysfd, buff, sizeof (buff));
-        sys_close (sysfd);
-
-        max_bytes = atoll (buff);
+    char *dm = NULL;
+    char dmname[4096] = {
+        0,
+    };
+    char lvname[4096] = {
+        0,
+    };
+    char sysfs[4096] = {
+        0,
+    };
+    bd_gfid_t uuid = {
+        0,
+    };
+    char *p = NULL;
+    off_t max_bytes = 0;
+    int sysfd = -1;
+    int ret = 0;
+    uint64_t param[2] = {0, 0};
+    off_t nr_loop = 0;
+    char buff[16] = {
+        0,
+    };
+
+    uuid_utoa_r(bdatt->iatt.ia_gfid, uuid);
+    sprintf(lvname, "/dev/%s/%s", vg, uuid);
+
+    ret = sys_readlink(lvname, dmname, 4096);
+    if (ret < 0) {
+        gf_log("bd", GF_LOG_DEBUG, "Failed to read symbolic link '%s': %s",
+               lvname, strerror(errno));
+        goto skip;
+    }
+
+    dmname[ret] = '\0';
+
+    p = strrchr(dmname, '/');
+    if (p)
+        dm = p + 1;
+    else
+        dm = dmname;
+
+    sprintf(sysfs, "/sys/block/%s/queue/write_same_max_bytes", dm);
+    sysfd = open(sysfs, O_RDONLY);
+    if (sysfd < 0) {
+        gf_log("bd_do_ioctl_zerofill", GF_LOG_DEBUG,
+               "sysfs file %s does not exist", lvname);
+        goto skip;
+    }
+
+    sys_read(sysfd, buff, sizeof(buff));
+    sys_close(sysfd);
+
+    max_bytes = atoll(buff);
 
 skip:
-        /*
-         * If requested len is less than write_same_max_bytes,
-         * issue single ioctl to zeroout. Otherwise split the ioctls
-         */
-        if (!max_bytes || len <= max_bytes) {
-                param[0] = offset;
-                param[1] = len;
-
-                if (ioctl (fd, BLKZEROOUT, param) < 0)
-                        return errno;
-                return 0;
-        }
+    /*
+     * If requested len is less than write_same_max_bytes,
+     * issue single ioctl to zeroout. Otherwise split the ioctls
+     */
+    if (!max_bytes || len <= max_bytes) {
+        param[0] = offset;
+        param[1] = len;
 
-        /* Split ioctls to max write_same_max_bytes */
-        nr_loop = len / max_bytes;
-        for (; nr_loop; nr_loop--) {
-                param[0] = offset;
-                param[1] = max_bytes;
+        if (ioctl(fd, BLKZEROOUT, param) < 0)
+            return errno;
+        return 0;
+    }
 
-                if (ioctl (fd, BLKZEROOUT, param) < 0)
-                        return errno;
+    /* Split ioctls to max write_same_max_bytes */
+    nr_loop = len / max_bytes;
+    for (; nr_loop; nr_loop--) {
+        param[0] = offset;
+        param[1] = max_bytes;
 
-                offset += max_bytes;
-        }
+        if (ioctl(fd, BLKZEROOUT, param) < 0)
+            return errno;
 
-        if (!(len % max_bytes))
-                return 0;
+        offset += max_bytes;
+    }
 
-        param[0] = offset;
-        param[1] = len % max_bytes;
+    if (!(len % max_bytes))
+        return 0;
 
-        if (ioctl (fd, BLKZEROOUT, param) < 0)
-                return errno;
+    param[0] = offset;
+    param[1] = len % max_bytes;
 
-        return 0;
+    if (ioctl(fd, BLKZEROOUT, param) < 0)
+        return errno;
+
+    return 0;
 }
 #endif
 
 int
-bd_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd,
-               off_t offset, size_t len, struct iatt *prebuf,
-               struct iatt *postbuf)
+bd_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+               size_t len, struct iatt *prebuf, struct iatt *postbuf)
 {
-        int          ret   = -1;
-        bd_fd_t     *bd_fd = NULL;
-        bd_priv_t   *priv  = this->private;
-        bd_attr_t   *bdatt = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (priv, out);
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "bd_fd is NULL from fd=%p", fd);
-                goto out;
-        }
-
-        bd_inode_ctx_get (fd->inode, this, &bdatt);
+    int ret = -1;
+    bd_fd_t *bd_fd = NULL;
+    bd_priv_t *priv = this->private;
+    bd_attr_t *bdatt = NULL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(priv, out);
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_DEBUG, "bd_fd is NULL from fd=%p", fd);
+        goto out;
+    }
+
+    bd_inode_ctx_get(fd->inode, this, &bdatt);
 #ifndef BLKZEROOUT
-        ret = bd_do_manual_zerofill(bd_fd->fd, offset, len,
-                                    bd_fd->flag & O_DIRECT);
+    ret = bd_do_manual_zerofill(bd_fd->fd, offset, len, bd_fd->flag & O_DIRECT);
 #else
-        ret = bd_do_ioctl_zerofill(priv, bdatt, bd_fd->fd, priv->vg, offset,
-                                   len);
+    ret = bd_do_ioctl_zerofill(priv, bdatt, bd_fd->fd, priv->vg, offset, len);
 #endif
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "zerofill failed on fd %d length %zu %s", bd_fd->fd, len,
+               strerror(ret));
+        goto out;
+    }
+
+    if (bd_fd->flag & (O_SYNC | O_DSYNC)) {
+        ret = sys_fsync(bd_fd->fd);
         if (ret) {
-                gf_log(this->name, GF_LOG_ERROR,
-                       "zerofill failed on fd %d length %zu %s",
-                       bd_fd->fd, len, strerror (ret));
-                goto out;
-        }
-
-        if (bd_fd->flag & (O_SYNC|O_DSYNC)) {
-                ret = sys_fsync (bd_fd->fd);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "fsync() in writev on fd %d failed: %s",
-                                bd_fd->fd, strerror (errno));
-                        return errno;
-                }
+            gf_log(this->name, GF_LOG_ERROR,
+                   "fsync() in writev on fd %d failed: %s", bd_fd->fd,
+                   strerror(errno));
+            return errno;
         }
+    }
 
-        memcpy (prebuf, &bdatt->iatt, sizeof (struct iatt));
-        bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME);
-        memcpy (postbuf, &bdatt->iatt, sizeof (struct iatt));
+    memcpy(prebuf, &bdatt->iatt, sizeof(struct iatt));
+    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
+    memcpy(postbuf, &bdatt->iatt, sizeof(struct iatt));
 
 out:
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/storage/bd/src/bd.c b/xlators/storage/bd/src/bd.c
index ccb4219785e..c66ce93b79e 100644
--- a/xlators/storage/bd/src/bd.c
+++ b/xlators/storage/bd/src/bd.c
@@ -42,206 +42,208 @@
  * does not do anything. FIXME: How to handle remove/setxattr failure
  */
 int
-bd_null_rmsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
+bd_null_rmsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xdata)
 {
-        STACK_DESTROY (frame->root);
-        return 0;
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 /*
  * returns 0 if a file is mapped to BD or not.
  */
 int
-bd_get_bd_info (call_frame_t *frame, xlator_t *this, dict_t *xattr, uuid_t gfid,
-                char **type, uint64_t *size)
+bd_get_bd_info(call_frame_t *frame, xlator_t *this, dict_t *xattr, uuid_t gfid,
+               char **type, uint64_t *size)
 {
-        char         *bd_xattr = NULL;
-        char         *bd       = NULL;
-        int           ret      = -1;
-        loc_t         loc      = {0, };
-        dict_t       *dict     = NULL;
-        char         *p        = NULL;
-        call_frame_t *bd_frame = NULL;
+    char *bd_xattr = NULL;
+    char *bd = NULL;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *p = NULL;
+    call_frame_t *bd_frame = NULL;
 
-        if (!xattr)
-                return 1;
+    if (!xattr)
+        return 1;
 
-        if (dict_get_str (xattr, BD_XATTR, &p))
-                return 1;
+    if (dict_get_str(xattr, BD_XATTR, &p))
+        return 1;
 
-        bd_xattr = gf_strdup (p);
+    bd_xattr = gf_strdup(p);
 
-        memcpy (loc.gfid, gfid, sizeof (uuid_t));
+    memcpy(loc.gfid, gfid, sizeof(uuid_t));
 
-        bd_frame = copy_frame (frame);
-        BD_VALIDATE_MEM_ALLOC (bd_frame, ret, out);
+    bd_frame = copy_frame(frame);
+    BD_VALIDATE_MEM_ALLOC(bd_frame, ret, out);
 
-        ret = bd_validate_bd_xattr (this,  bd_xattr, type, size, gfid);
-        if (ret < 0) {/* LV does not exist */
-                STACK_WIND (bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->removexattr, &loc,
-                            BD_XATTR, NULL);
+    ret = bd_validate_bd_xattr(this, bd_xattr, type, size, gfid);
+    if (ret < 0) { /* LV does not exist */
+        STACK_WIND(bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->removexattr, &loc, BD_XATTR, NULL);
 
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Mapped LV not available for posix file <gfid:%s>, "
-                        "deleting mapping", uuid_utoa (gfid));
-        } else if (ret == 1) {
-                /* BD_XATTR size and LV size mismatch. Update BD_XATTR */
-                gf_asprintf (&bd, "%s:%ld", *type, *size);
+        gf_log(this->name, GF_LOG_WARNING,
+               "Mapped LV not available for posix file <gfid:%s>, "
+               "deleting mapping",
+               uuid_utoa(gfid));
+    } else if (ret == 1) {
+        /* BD_XATTR size and LV size mismatch. Update BD_XATTR */
+        gf_asprintf(&bd, "%s:%ld", *type, *size);
 
-                dict = dict_new ();
-                BD_VALIDATE_MEM_ALLOC (dict, ret, out);
+        dict = dict_new();
+        BD_VALIDATE_MEM_ALLOC(dict, ret, out);
 
-                ret = dict_set_dynstr (dict, BD_XATTR, bd);
-                if (ret)
-                        goto out;
+        ret = dict_set_dynstr(dict, BD_XATTR, bd);
+        if (ret)
+            goto out;
 
-                STACK_WIND (bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->setxattr, &loc, dict, 0,
-                            NULL);
-        }
+        STACK_WIND(bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setxattr, &loc, dict, 0, NULL);
+    }
 
 out:
-        dict_del (xattr, BD_XATTR);
-        GF_FREE (bd_xattr);
-        GF_FREE (bd);
-        return ret;
+    dict_del(xattr, BD_XATTR);
+    GF_FREE(bd_xattr);
+    GF_FREE(bd);
+    return ret;
 }
 
 /*
  * bd_lookup_cbk: Call back from posix_lookup.
  */
 int32_t
-bd_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, inode_t *inode, struct iatt *buf, dict_t *xattr,
-               struct iatt *postparent)
-{
-        int           ret    = -1;
-        bd_attr_t    *bdatt  = NULL;
-        uint64_t      size   = 0;
-        char         *type   = NULL;
-
-        /* only regular files are part of BD object */
-        if (op_ret < 0 || buf->ia_type != IA_IFREG)
-                goto out;
-
-        /* iatt already cached */
-        if (!bd_inode_ctx_get (inode, this, &bdatt))
-                goto next;
-
-        if (bd_get_bd_info (frame, this, xattr, buf->ia_gfid, &type, &size))
-                goto out;
-
-        /* BD file, update buf */
-        bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr);
-        if (!bdatt) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-        memcpy (&bdatt->iatt, buf, sizeof (struct iatt));
-        bdatt->type = type;
-
-        /* Cache LV size in inode_ctx */
-        ret = bd_inode_ctx_set (inode, this, bdatt);
-        if (ret < 0) {
-                GF_FREE (bdatt);
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        bdatt->iatt.ia_size = size;
-        bdatt->iatt.ia_blocks = size / 512;
+bd_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, inode_t *inode, struct iatt *buf, dict_t *xattr,
+              struct iatt *postparent)
+{
+    int ret = -1;
+    bd_attr_t *bdatt = NULL;
+    uint64_t size = 0;
+    char *type = NULL;
+
+    /* only regular files are part of BD object */
+    if (op_ret < 0 || buf->ia_type != IA_IFREG)
+        goto out;
+
+    /* iatt already cached */
+    if (!bd_inode_ctx_get(inode, this, &bdatt))
+        goto next;
+
+    if (bd_get_bd_info(frame, this, xattr, buf->ia_gfid, &type, &size))
+        goto out;
+
+    /* BD file, update buf */
+    bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
+    if (!bdatt) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+    memcpy(&bdatt->iatt, buf, sizeof(struct iatt));
+    bdatt->type = type;
+
+    /* Cache LV size in inode_ctx */
+    ret = bd_inode_ctx_set(inode, this, bdatt);
+    if (ret < 0) {
+        GF_FREE(bdatt);
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    bdatt->iatt.ia_size = size;
+    bdatt->iatt.ia_blocks = size / 512;
 
 next:
-        dict_del (xattr, GF_CONTENT_KEY);
-        memcpy (buf, &bdatt->iatt, sizeof (struct iatt));
+    dict_del(xattr, GF_CONTENT_KEY);
+    memcpy(buf, &bdatt->iatt, sizeof(struct iatt));
 
 out:
-        BD_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, buf,
-                         xattr, postparent);
-        return 0;
+    BD_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, xattr,
+                    postparent);
+    return 0;
 }
 
 /*
  * bd_lookup: Issues posix_lookup to find out if file is mapped to BD
  * bd_lookup -> posix_lookup -> bd_lookup_cbk
-*/
+ */
 int32_t
-bd_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
-{
-        dict_t     *bd_xattr = NULL;
-        bd_attr_t  *bdatt    = NULL;
-        int         op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (loc, out);
-        VALIDATE_OR_GOTO (loc->path, out);
-        VALIDATE_OR_GOTO (this->private, out);
-
-        if (bd_inode_ctx_get (loc->inode, this, &bdatt) < 0) {
-                if (!xattr_req) {
-                        bd_xattr = dict_new ();
-                        BD_VALIDATE_MEM_ALLOC (bd_xattr, op_errno, out);
-                        xattr_req = bd_xattr;
-                }
-                if (dict_set_int8 (xattr_req, BD_XATTR, 1) < 0)
-                        goto out;
+bd_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    dict_t *bd_xattr = NULL;
+    bd_attr_t *bdatt = NULL;
+    int op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(loc, out);
+    VALIDATE_OR_GOTO(loc->path, out);
+    VALIDATE_OR_GOTO(this->private, out);
+
+    if (bd_inode_ctx_get(loc->inode, this, &bdatt) < 0) {
+        if (!xattr_req) {
+            bd_xattr = dict_new();
+            BD_VALIDATE_MEM_ALLOC(bd_xattr, op_errno, out);
+            xattr_req = bd_xattr;
         }
+        if (dict_set_int8(xattr_req, BD_XATTR, 1) < 0)
+            goto out;
+    }
 
-        STACK_WIND (frame, bd_lookup_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->lookup, loc, xattr_req);
+    STACK_WIND(frame, bd_lookup_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->lookup, loc, xattr_req);
 
-        if (bd_xattr)
-                dict_unref (bd_xattr);
-        return 0;
+    if (bd_xattr)
+        dict_unref(bd_xattr);
+    return 0;
 out:
-        BD_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    BD_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_forget (xlator_t *this, inode_t *inode)
+bd_forget(xlator_t *this, inode_t *inode)
 {
-        int          ret   = -1;
-        uint64_t     ctx   = 0;
-        bd_attr_t   *bdatt = NULL;
+    int ret = -1;
+    uint64_t ctx = 0;
+    bd_attr_t *bdatt = NULL;
 
-        ret = bd_inode_ctx_get (inode, this, &bdatt);
-        if (!ret) {
-                inode_ctx_del (inode, this, &ctx);
-                GF_FREE (bdatt);
-        }
-        return 0;
+    ret = bd_inode_ctx_get(inode, this, &bdatt);
+    if (!ret) {
+        inode_ctx_del(inode, this, &ctx);
+        GF_FREE(bdatt);
+    }
+    return 0;
 }
 
 int
-bd_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                 int op_errno, gf_dirent_t *entries, dict_t *xdata)
-{
-        gf_dirent_t    *entry  = NULL;
-        uint64_t        size   = 0;
-        char           *type   = NULL;
-
-        if (op_ret < 0)
-                goto out;
-
-        list_for_each_entry (entry, &entries->list, list) {
-                if (entry->d_type != DT_REG)
-                        continue;
-                if (!bd_get_bd_info (frame, this, entry->dict,
-                                     entry->d_stat.ia_gfid, &type, &size)) {
-                        entry->d_stat.ia_size = size;
-                        entry->d_stat.ia_blocks = size / 512;
-                        GF_FREE (type);
-                }
+bd_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, gf_dirent_t *entries, dict_t *xdata)
+{
+    gf_dirent_t *entry = NULL;
+    uint64_t size = 0;
+    char *type = NULL;
+
+    if (op_ret < 0)
+        goto out;
+
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        if (entry->d_type != DT_REG)
+            continue;
+        if (!bd_get_bd_info(frame, this, entry->dict, entry->d_stat.ia_gfid,
+                            &type, &size)) {
+            entry->d_stat.ia_size = size;
+            entry->d_stat.ia_blocks = size / 512;
+            GF_FREE(type);
         }
+    }
 
 out:
-        BD_STACK_UNWIND (readdirp, frame, op_ret, op_errno, entries, xdata);
-        return 0;
+    BD_STACK_UNWIND(readdirp, frame, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
 /*
@@ -249,198 +251,196 @@ out:
  * ia_size is updated with the LV(BD_XATTR_SIZE) size
  */
 int32_t
-bd_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t off, dict_t *dict)
-{
-        int          op_errno = EINVAL;
-        bd_local_t  *local    = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (this->private, out);
-
-        if (!dict) {
-                local = bd_local_init (frame, this);
-                BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
-                local->dict = dict_new ();
-                BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out);
-                dict = local->dict;
-        }
-
-        if (dict_set_int8 (dict, BD_XATTR, 0)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set key %s", BD_XATTR);
-                goto out;
-        }
-
-        STACK_WIND (frame, bd_readdirp_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict);
-
-        return 0;
+bd_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t off, dict_t *dict)
+{
+    int op_errno = EINVAL;
+    bd_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(this->private, out);
+
+    if (!dict) {
+        local = bd_local_init(frame, this);
+        BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
+        local->dict = dict_new();
+        BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
+        dict = local->dict;
+    }
+
+    if (dict_set_int8(dict, BD_XATTR, 0)) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set key %s", BD_XATTR);
+        goto out;
+    }
+
+    STACK_WIND(frame, bd_readdirp_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict);
+
+    return 0;
 out:
-        BD_STACK_UNWIND (readdirp, frame, -1, op_errno, NULL, dict);
-        return 0;
+    BD_STACK_UNWIND(readdirp, frame, -1, op_errno, NULL, dict);
+    return 0;
 }
 
 int
-bd_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-             int op_errno, struct iatt *buf, dict_t *xdata)
+bd_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+            int op_errno, struct iatt *buf, dict_t *xdata)
 {
-        bd_local_t  *local = frame->local;
-        bd_attr_t   *bdatt = NULL;
+    bd_local_t *local = frame->local;
+    bd_attr_t *bdatt = NULL;
 
-        /* only regular files are part of BD object */
-        if (op_ret < 0 || buf->ia_type != IA_IFREG)
-                goto out;
+    /* only regular files are part of BD object */
+    if (op_ret < 0 || buf->ia_type != IA_IFREG)
+        goto out;
 
-        BD_VALIDATE_LOCAL_OR_GOTO (local, op_errno, out);
+    BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out);
 
-        /* update buf with LV size */
-        if (!bd_inode_ctx_get (local->inode, this, &bdatt))
-                memcpy (buf, bdatt, sizeof (struct iatt));
+    /* update buf with LV size */
+    if (!bd_inode_ctx_get(local->inode, this, &bdatt))
+        memcpy(buf, bdatt, sizeof(struct iatt));
 
 out:
-        BD_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata);
-        return 0;
+    BD_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
 int
-bd_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+bd_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        int          op_errno = EINVAL;
-        bd_local_t  *local    = NULL;
-        bd_attr_t   *bdatt    = NULL;
+    int op_errno = EINVAL;
+    bd_local_t *local = NULL;
+    bd_attr_t *bdatt = NULL;
 
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (loc, out);
-        VALIDATE_OR_GOTO (loc->path, out);
-        VALIDATE_OR_GOTO (this->private, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(loc, out);
+    VALIDATE_OR_GOTO(loc->path, out);
+    VALIDATE_OR_GOTO(this->private, out);
 
-        if (!bd_inode_ctx_get (loc->inode, this, &bdatt)) {
-                BD_STACK_UNWIND (stat, frame, 0, 0, &bdatt->iatt, xdata);
-                return 0;
-        }
+    if (!bd_inode_ctx_get(loc->inode, this, &bdatt)) {
+        BD_STACK_UNWIND(stat, frame, 0, 0, &bdatt->iatt, xdata);
+        return 0;
+    }
 
-        local = bd_local_init (frame, this);
-        BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
-        local->inode = inode_ref (loc->inode);
+    local = bd_local_init(frame, this);
+    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
+    local->inode = inode_ref(loc->inode);
 
-        STACK_WIND(frame, bd_stat_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->stat, loc, xdata);
-        return 0;
+    STACK_WIND(frame, bd_stat_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->stat, loc, xdata);
+    return 0;
 out:
-        BD_STACK_UNWIND (stat, frame, -1, op_errno, NULL, xdata);
-        return 0;
+    BD_STACK_UNWIND(stat, frame, -1, op_errno, NULL, xdata);
+    return 0;
 }
 
 int
-bd_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, struct statvfs *buff, dict_t *xdata)
-{
-        uint64_t      size    = 0;
-        uint64_t      fr_size = 0;
-        bd_priv_t    *priv    = NULL;
-        vg_t          vg      = NULL;
-
-        if (op_ret < 0)
-                goto out;
-
-        priv = this->private;
-
-        vg = lvm_vg_open (priv->handle, priv->vg, "r", 0);
-        if (!vg) {
-                gf_log (this->name, GF_LOG_WARNING, "opening VG %s failed",
-                        priv->vg);
-                op_ret = -1;
-                op_errno = EAGAIN;
-                goto out;
-        }
-        size = lvm_vg_get_size (vg);
-        fr_size = lvm_vg_get_free_size (vg);
-        lvm_vg_close (vg);
-
-        buff->f_blocks += size / buff->f_frsize;
-        buff->f_bfree += fr_size / buff->f_frsize;
-        buff->f_bavail += fr_size / buff->f_frsize;
+bd_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct statvfs *buff, dict_t *xdata)
+{
+    uint64_t size = 0;
+    uint64_t fr_size = 0;
+    bd_priv_t *priv = NULL;
+    vg_t vg = NULL;
+
+    if (op_ret < 0)
+        goto out;
+
+    priv = this->private;
+
+    vg = lvm_vg_open(priv->handle, priv->vg, "r", 0);
+    if (!vg) {
+        gf_log(this->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
+        op_ret = -1;
+        op_errno = EAGAIN;
+        goto out;
+    }
+    size = lvm_vg_get_size(vg);
+    fr_size = lvm_vg_get_free_size(vg);
+    lvm_vg_close(vg);
+
+    buff->f_blocks += size / buff->f_frsize;
+    buff->f_bfree += fr_size / buff->f_frsize;
+    buff->f_bavail += fr_size / buff->f_frsize;
 
 out:
-        BD_STACK_UNWIND (statfs, frame, op_ret, op_errno, buff, xdata);
-        return 0;
+    BD_STACK_UNWIND(statfs, frame, op_ret, op_errno, buff, xdata);
+    return 0;
 }
 
 /*
  * bd_statfs: Mimics statfs by returning used/free extents in the VG
  */
 int
-bd_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+bd_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (this->private, out);
-        VALIDATE_OR_GOTO (loc, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(this->private, out);
+    VALIDATE_OR_GOTO(loc, out);
 
-        STACK_WIND (frame, bd_statfs_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->statfs, loc, xdata);
-        return 0;
+    STACK_WIND(frame, bd_statfs_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->statfs, loc, xdata);
+    return 0;
 out:
-        BD_STACK_UNWIND (statfs, frame, -1, EINVAL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(statfs, frame, -1, EINVAL, NULL, NULL);
+    return 0;
 }
 
 int
-bd_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-              int op_errno, struct iatt *buf, dict_t *xdata)
+bd_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, struct iatt *buf, dict_t *xdata)
 {
-        bd_attr_t  *bdatt = NULL;
-        bd_local_t *local = frame->local;
+    bd_attr_t *bdatt = NULL;
+    bd_local_t *local = frame->local;
 
-        /* only regular files are part of BD object */
-        if (op_ret < 0 || buf->ia_type != IA_IFREG)
-                goto out;
+    /* only regular files are part of BD object */
+    if (op_ret < 0 || buf->ia_type != IA_IFREG)
+        goto out;
 
-        BD_VALIDATE_LOCAL_OR_GOTO (local, op_errno, out);
+    BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out);
 
-        /* update buf with LV size */
-        if (!bd_inode_ctx_get (local->inode, this, &bdatt))
-                memcpy (buf, &bdatt->iatt, sizeof (struct iatt));
+    /* update buf with LV size */
+    if (!bd_inode_ctx_get(local->inode, this, &bdatt))
+        memcpy(buf, &bdatt->iatt, sizeof(struct iatt));
 
 out:
-        BD_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata);
-        return 0;
+    BD_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
 int
-bd_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+bd_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        int          op_errno = EINVAL;
-        bd_local_t  *local    = NULL;
-        bd_attr_t   *bdatt    = NULL;
+    int op_errno = EINVAL;
+    bd_local_t *local = NULL;
+    bd_attr_t *bdatt = NULL;
 
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (this->private, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(this->private, out);
 
-        /* if its already cached return it */
-        if (!bd_inode_ctx_get (fd->inode, this, &bdatt)) {
-                BD_STACK_UNWIND (fstat, frame, 0, 0, &bdatt->iatt, xdata);
-                return 0;
-        }
+    /* if its already cached return it */
+    if (!bd_inode_ctx_get(fd->inode, this, &bdatt)) {
+        BD_STACK_UNWIND(fstat, frame, 0, 0, &bdatt->iatt, xdata);
+        return 0;
+    }
 
-        local = bd_local_init (frame, this);
-        BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
+    local = bd_local_init(frame, this);
+    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
 
-        local->inode = inode_ref (fd->inode);
+    local->inode = inode_ref(fd->inode);
 
-        STACK_WIND (frame, bd_fstat_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fstat, fd, xdata);
+    STACK_WIND(frame, bd_fstat_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fstat, fd, xdata);
 
-        return 0;
+    return 0;
 out:
-        BD_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, xdata);
-        return 0;
+    BD_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, xdata);
+    return 0;
 }
 
 /*
@@ -448,80 +448,81 @@ out:
  * file
  */
 int
-bd_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-          off_t offset, uint32_t flags, dict_t *xdata)
-{
-        int             ret        = -1;
-        int             _fd        = -1;
-        int32_t         op_ret     = -1;
-        int32_t         op_errno   = 0;
-        bd_fd_t        *bd_fd      = NULL;
-        struct iovec    vec        = {0, };
-        struct iobuf   *iobuf      = NULL;
-        struct iobref  *iobref     = NULL;
-        uint64_t        bd_size    = 0;
-        bd_attr_t      *bdatt      = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (this->private, out);
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd) {
-                STACK_WIND (frame, default_readv_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->readv,
-                            fd, size, offset, flags, xdata);
-                return 0;
-        }
-        if (!size) {
-                op_errno = EINVAL;
-                gf_log (this->name, GF_LOG_WARNING, "size=%"GF_PRI_SIZET, size);
-                goto out;
-        }
-        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-        if (!iobuf) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-        _fd = bd_fd->fd;
-        op_ret = sys_pread (_fd, iobuf->ptr, size, offset);
-        if (op_ret == -1) {
-                op_errno = errno;
-                gf_log (this->name, GF_LOG_ERROR,
-                                "read failed on fd=%p: %s", fd,
-                                strerror (op_errno));
-                goto out;
-        }
-
-        vec.iov_base = iobuf->ptr;
-        vec.iov_len = op_ret;
-
-        iobref = iobref_new ();
-        iobref_add (iobref, iobuf);
-
-        if (bd_inode_ctx_get (fd->inode, this, &bdatt)) {
-                op_errno = EINVAL;
-                op_ret = -1;
-                goto out;
-        }
-        bd_size = bdatt->iatt.ia_size;
-        if (!bd_size || (offset + vec.iov_len) >= bd_size)
-                op_errno = ENOENT;
-
-        op_ret = vec.iov_len;
-        bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_ATIME);
+bd_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+         off_t offset, uint32_t flags, dict_t *xdata)
+{
+    int ret = -1;
+    int _fd = -1;
+    int32_t op_ret = -1;
+    int32_t op_errno = 0;
+    bd_fd_t *bd_fd = NULL;
+    struct iovec vec = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    uint64_t bd_size = 0;
+    bd_attr_t *bdatt = NULL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(this->private, out);
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd) {
+        STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->readv, fd, size, offset, flags,
+                   xdata);
+        return 0;
+    }
+    if (!size) {
+        op_errno = EINVAL;
+        gf_log(this->name, GF_LOG_WARNING, "size=%" GF_PRI_SIZET, size);
+        goto out;
+    }
+    iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+    if (!iobuf) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+    _fd = bd_fd->fd;
+    op_ret = sys_pread(_fd, iobuf->ptr, size, offset);
+    if (op_ret == -1) {
+        op_errno = errno;
+        gf_log(this->name, GF_LOG_ERROR, "read failed on fd=%p: %s", fd,
+               strerror(op_errno));
+        goto out;
+    }
+
+    vec.iov_base = iobuf->ptr;
+    vec.iov_len = op_ret;
+
+    iobref = iobref_new();
+    iobref_add(iobref, iobuf);
+
+    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
+        op_errno = EINVAL;
+        op_ret = -1;
+        goto out;
+    }
+    bd_size = bdatt->iatt.ia_size;
+    if (!bd_size || (offset + vec.iov_len) >= bd_size)
+        op_errno = ENOENT;
+
+    op_ret = vec.iov_len;
+    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_ATIME);
 
 out:
-        BD_STACK_UNWIND (readv, frame, op_ret, op_errno,
-                         &vec, 1, &bdatt->iatt, iobref, NULL);
+    BD_STACK_UNWIND(readv, frame, op_ret, op_errno, &vec, 1, &bdatt->iatt,
+                    iobref, NULL);
 
-        if (iobref)
-                iobref_unref (iobref);
-        if (iobuf)
-                iobuf_unref (iobuf);
+    if (iobref)
+        iobref_unref(iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        return 0;
+    return 0;
 }
 
 #ifdef BLKDISCARD
@@ -529,64 +530,67 @@ out:
  * bd_discard: Sends BLKDISCARD ioctl to the block device
  */
 int
-bd_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            size_t len, dict_t *xdata)
-{
-        int           ret      = -1;
-        int           op_errno = EINVAL;
-        bd_fd_t      *bd_fd    = NULL;
-        uint64_t      param[2] = {0, };
-        bd_attr_t    *bdatt    = NULL;
-        struct iatt   prebuf   = {0, };
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (this->private, out);
-        VALIDATE_OR_GOTO (fd, out);
-
-        /* posix */
-        if (bd_inode_ctx_get (fd->inode, this, &bdatt)) {
-                STACK_WIND (frame, default_discard_cbk, FIRST_CHILD(this),
-                           FIRST_CHILD(this)->fops->discard,
-                           fd, offset, len, xdata);
-                return 0;
-        }
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        param[0] = offset;
-        param[1] = len;
-        ret = ioctl (bd_fd->fd, BLKDISCARD, param);
-        if (ret < 0) {
-                if (errno == ENOTTY)
-                        op_errno = ENOSYS;
-                else
-                        op_errno = errno;
-                goto out;
-        }
-        memcpy (&prebuf, &bdatt->iatt, sizeof (prebuf));
-        bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME);
+bd_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+           size_t len, dict_t *xdata)
+{
+    int ret = -1;
+    int op_errno = EINVAL;
+    bd_fd_t *bd_fd = NULL;
+    uint64_t param[2] = {
+        0,
+    };
+    bd_attr_t *bdatt = NULL;
+    struct iatt prebuf = {
+        0,
+    };
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(this->private, out);
+    VALIDATE_OR_GOTO(fd, out);
+
+    /* posix */
+    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
+        STACK_WIND(frame, default_discard_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata);
+        return 0;
+    }
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    param[0] = offset;
+    param[1] = len;
+    ret = ioctl(bd_fd->fd, BLKDISCARD, param);
+    if (ret < 0) {
+        if (errno == ENOTTY)
+            op_errno = ENOSYS;
+        else
+            op_errno = errno;
+        goto out;
+    }
+    memcpy(&prebuf, &bdatt->iatt, sizeof(prebuf));
+    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
 
-        BD_STACK_UNWIND (discard, frame, ret, op_errno, &prebuf,
-                         &bdatt->iatt, xdata);
-        return 0;
+    BD_STACK_UNWIND(discard, frame, ret, op_errno, &prebuf, &bdatt->iatt,
+                    xdata);
+    return 0;
 
 out:
-        BD_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 #else
 
 int
-bd_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            size_t len, dict_t *xdata)
+bd_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+           size_t len, dict_t *xdata)
 {
-        BD_STACK_UNWIND (discard, frame, -1, ENOSYS, NULL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(discard, frame, -1, ENOSYS, NULL, NULL, NULL);
+    return 0;
 }
 #endif
 
@@ -595,32 +599,31 @@ bd_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
  * If it failed, close BD fd
  */
 int
-bd_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+bd_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+            int op_errno, fd_t *fd, dict_t *xdata)
 {
-        bd_fd_t    *bd_fd = NULL;
-        bd_attr_t  *bdatt = NULL;
+    bd_fd_t *bd_fd = NULL;
+    bd_attr_t *bdatt = NULL;
 
-        if (!op_ret)
-                goto out;
+    if (!op_ret)
+        goto out;
 
-        bd_inode_ctx_get (fd->inode, this, &bdatt);
-        if (!bdatt) /* posix file */
-                goto out;
+    bd_inode_ctx_get(fd->inode, this, &bdatt);
+    if (!bdatt) /* posix file */
+        goto out;
 
-        /* posix open failed */
-        if (bd_fd_ctx_get (this, fd, &bd_fd) < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "bd_fd is NULL from fd=%p", fd);
-                goto out;
-        }
-        sys_close (bd_fd->fd);
-        GF_FREE (bd_fd);
+    /* posix open failed */
+    if (bd_fd_ctx_get(this, fd, &bd_fd) < 0) {
+        gf_log(this->name, GF_LOG_WARNING, "bd_fd is NULL from fd=%p", fd);
+        goto out;
+    }
+    sys_close(bd_fd->fd);
+    GF_FREE(bd_fd);
 
 out:
-        BD_STACK_UNWIND (open, frame, op_ret, op_errno, fd, NULL);
+    BD_STACK_UNWIND(open, frame, op_ret, op_errno, fd, NULL);
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -629,270 +632,270 @@ out:
  * fd contains both posix and BD fd
  */
 int32_t
-bd_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, dict_t *xdata)
-{
-        int32_t      ret     = EINVAL;
-        bd_fd_t     *bd_fd   = NULL;
-        bd_attr_t   *bdatt   = NULL;
-        bd_gfid_t    gfid    = {0, };
-        char        *devpath = NULL;
-        bd_priv_t   *priv    = this->private;
-        int         _fd      = -1;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (this->private, out);
-        VALIDATE_OR_GOTO (loc, out);
-        VALIDATE_OR_GOTO (fd, out);
-
-        /* not bd file */
-        if (fd->inode->ia_type != IA_IFREG ||
-            bd_inode_ctx_get (fd->inode, this, &bdatt))
-                goto posix;
-
-        uuid_utoa_r (fd->inode->gfid, gfid);
-        gf_asprintf (&devpath, "/dev/%s/%s", priv->vg, gfid);
-        BD_VALIDATE_MEM_ALLOC (devpath, ret, out);
-
-        _fd = open (devpath, flags | O_LARGEFILE, 0);
-        if (_fd < 0) {
-                ret = errno;
-                gf_log (this->name, GF_LOG_ERROR, "open on %s: %s", devpath,
-                        strerror (ret));
-                goto out;
-        }
-        bd_fd = GF_CALLOC (1, sizeof(bd_fd_t), gf_bd_fd);
-        BD_VALIDATE_MEM_ALLOC (bd_fd, ret, out);
-
-        bd_fd->fd = _fd;
-        bd_fd->flag = flags | O_LARGEFILE;
-
-        if (fd_ctx_set (fd, this, (uint64_t)(long)bd_fd) < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set the fd context fd=%p", fd);
-                goto out;
-        }
-
-        ret = 0;
+bd_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+        fd_t *fd, dict_t *xdata)
+{
+    int32_t ret = EINVAL;
+    bd_fd_t *bd_fd = NULL;
+    bd_attr_t *bdatt = NULL;
+    bd_gfid_t gfid = {
+        0,
+    };
+    char *devpath = NULL;
+    bd_priv_t *priv = this->private;
+    int _fd = -1;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(this->private, out);
+    VALIDATE_OR_GOTO(loc, out);
+    VALIDATE_OR_GOTO(fd, out);
+
+    /* not bd file */
+    if (fd->inode->ia_type != IA_IFREG ||
+        bd_inode_ctx_get(fd->inode, this, &bdatt))
+        goto posix;
+
+    uuid_utoa_r(fd->inode->gfid, gfid);
+    gf_asprintf(&devpath, "/dev/%s/%s", priv->vg, gfid);
+    BD_VALIDATE_MEM_ALLOC(devpath, ret, out);
+
+    _fd = open(devpath, flags | O_LARGEFILE, 0);
+    if (_fd < 0) {
+        ret = errno;
+        gf_log(this->name, GF_LOG_ERROR, "open on %s: %s", devpath,
+               strerror(ret));
+        goto out;
+    }
+    bd_fd = GF_CALLOC(1, sizeof(bd_fd_t), gf_bd_fd);
+    BD_VALIDATE_MEM_ALLOC(bd_fd, ret, out);
+
+    bd_fd->fd = _fd;
+    bd_fd->flag = flags | O_LARGEFILE;
+
+    if (fd_ctx_set(fd, this, (uint64_t)(long)bd_fd) < 0) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set the fd context fd=%p",
+               fd);
+        goto out;
+    }
+
+    ret = 0;
 
 posix:
 
-        /* open posix equivalent of this file, fd needed for fd related
-           operations like fsetxattr, ftruncate etc */
-        STACK_WIND (frame, bd_open_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
+    /* open posix equivalent of this file, fd needed for fd related
+       operations like fsetxattr, ftruncate etc */
+    STACK_WIND(frame, bd_open_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
 
-        GF_FREE (devpath);
-        return 0;
+    GF_FREE(devpath);
+    return 0;
 out:
-        BD_STACK_UNWIND (open, frame, -1, ret, fd, NULL);
+    BD_STACK_UNWIND(open, frame, -1, ret, fd, NULL);
 
-        GF_FREE (devpath);
-        if (ret) {
-                if (_fd >= 0)
-                        sys_close (_fd);
-                GF_FREE (bd_fd);
-        }
+    GF_FREE(devpath);
+    if (ret) {
+        if (_fd >= 0)
+            sys_close(_fd);
+        GF_FREE(bd_fd);
+    }
 
-        return 0;
+    return 0;
 }
 
 /*
  * call back from posix_setattr after updating iatt to posix file.
  */
 int
-bd_fsync_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *pre,
-                      struct iatt *post, dict_t *xdata)
+bd_fsync_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *pre,
+                     struct iatt *post, dict_t *xdata)
 {
-        bd_local_t *local = frame->local;
-        bd_attr_t  *bdatt = local->bdatt;
+    bd_local_t *local = frame->local;
+    bd_attr_t *bdatt = local->bdatt;
 
-        BD_STACK_UNWIND (fsync, frame, op_ret, op_errno, &bdatt->iatt,
-                         &bdatt->iatt, NULL);
-        return 0;
+    BD_STACK_UNWIND(fsync, frame, op_ret, op_errno, &bdatt->iatt, &bdatt->iatt,
+                    NULL);
+    return 0;
 }
 
 int
-bd_do_fsync (int fd, int datasync)
+bd_do_fsync(int fd, int datasync)
 {
-        int   op_errno = 0;
+    int op_errno = 0;
 
-        if (datasync) {
-                if (sys_fdatasync (fd)) {
-                        op_errno = errno;
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "fdatasync on fd=%d failed: %s",
-                                fd, strerror (errno));
-                }
+    if (datasync) {
+        if (sys_fdatasync(fd)) {
+            op_errno = errno;
+            gf_log(THIS->name, GF_LOG_ERROR, "fdatasync on fd=%d failed: %s",
+                   fd, strerror(errno));
+        }
 
-        } else
+    } else
 
-        {
-                if (sys_fsync (fd)) {
-                        op_errno = errno;
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "fsync on fd=%d failed: %s",
-                                 fd, strerror (op_errno));
-                }
+    {
+        if (sys_fsync(fd)) {
+            op_errno = errno;
+            gf_log(THIS->name, GF_LOG_ERROR, "fsync on fd=%d failed: %s", fd,
+                   strerror(op_errno));
         }
+    }
 
-        return op_errno;
+    return op_errno;
 }
 
 /*
  * bd_fsync: Syncs if BD fd, forwards the request to posix
  * fsync -> posix_setattr -> posix_fsync
-*/
+ */
 int32_t
-bd_fsync (call_frame_t *frame, xlator_t *this,
-          fd_t *fd, int32_t datasync, dict_t *xdata)
-{
-        int         ret      = -1;
-        int32_t     op_ret   = -1;
-        int32_t     op_errno = 0;
-        bd_fd_t    *bd_fd    = NULL;
-        bd_attr_t  *bdatt    = NULL;
-        bd_local_t *local    = NULL;
-        int         valid    = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
-        struct iatt prebuf   = {0, };
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (this->private, out);
-
-        ret = bd_inode_ctx_get (fd->inode, this, &bdatt);
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd || !bdatt) {
-                STACK_WIND (frame, default_fsync_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->fsync, fd, datasync,
-                            xdata);
-                return 0;
-        }
-
-        memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt));
-
-        op_errno = bd_do_fsync (bd_fd->fd, datasync);
-        if (op_errno)
-                goto out;
-
-        /* For BD, Update the a|mtime during full fsync only */
-        if (!datasync) {
-                local = bd_local_init (frame, this);
-                /* In case of mem failure, should posix flush called ? */
-                BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
-
-                local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr);
-                BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out);
-
-                local->bdatt->type = gf_strdup (bdatt->type);
-                memcpy (&local->bdatt->iatt, &bdatt->iatt, sizeof (struct iatt));
-                bd_update_amtime (&local->bdatt->iatt, valid);
-                gf_uuid_copy (local->loc.gfid, fd->inode->gfid);
-                STACK_WIND (frame, bd_fsync_setattr_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->setattr, &local->loc,
-                            &local->bdatt->iatt,
-                            valid, NULL);
-                return 0;
-        }
+bd_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+         dict_t *xdata)
+{
+    int ret = -1;
+    int32_t op_ret = -1;
+    int32_t op_errno = 0;
+    bd_fd_t *bd_fd = NULL;
+    bd_attr_t *bdatt = NULL;
+    bd_local_t *local = NULL;
+    int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
+    struct iatt prebuf = {
+        0,
+    };
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(this->private, out);
+
+    ret = bd_inode_ctx_get(fd->inode, this, &bdatt);
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd || !bdatt) {
+        STACK_WIND(frame, default_fsync_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata);
+        return 0;
+    }
+
+    memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
+
+    op_errno = bd_do_fsync(bd_fd->fd, datasync);
+    if (op_errno)
+        goto out;
+
+    /* For BD, Update the a|mtime during full fsync only */
+    if (!datasync) {
+        local = bd_local_init(frame, this);
+        /* In case of mem failure, should posix flush called ? */
+        BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
+
+        local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
+        BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
+
+        local->bdatt->type = gf_strdup(bdatt->type);
+        memcpy(&local->bdatt->iatt, &bdatt->iatt, sizeof(struct iatt));
+        bd_update_amtime(&local->bdatt->iatt, valid);
+        gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
+        STACK_WIND(frame, bd_fsync_setattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setattr, &local->loc,
+                   &local->bdatt->iatt, valid, NULL);
+        return 0;
+    }
 
 out:
-        BD_STACK_UNWIND (fsync, frame, op_ret, op_errno, &prebuf,
-                         &bdatt->iatt, NULL);
-        return 0;
+    BD_STACK_UNWIND(fsync, frame, op_ret, op_errno, &prebuf, &bdatt->iatt,
+                    NULL);
+    return 0;
 }
 
 int
-bd_flush_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *pre,
-                      struct iatt *post, dict_t *xdata)
+bd_flush_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *pre,
+                     struct iatt *post, dict_t *xdata)
 {
-        BD_STACK_UNWIND (flush, frame, op_ret, op_errno, xdata);
-        return 0;
+    BD_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int
-bd_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-        int          ret    = -1;
-        bd_fd_t     *bd_fd  = NULL;
-        bd_attr_t   *bdatt  = NULL;
-        int          valid    = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
-        bd_local_t  *local    = NULL;
-        loc_t        loc      = {0, };
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (this->private, out);
-
-        ret = bd_inode_ctx_get (fd->inode, this, &bdatt);
-        if (!bdatt)
-                goto out;
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd || !bdatt) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "bdfd/bdatt is NULL from fd=%p", fd);
-                goto out;
-        }
-
-        local = bd_local_init (frame, this);
-        if (!local) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                goto out;
-        }
-
-        local->fd = fd_ref (fd);
-        gf_uuid_copy (loc.gfid, bdatt->iatt.ia_gfid);
-
-        /* Update the a|mtime during flush */
-        STACK_WIND (frame, bd_flush_setattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->setattr, &loc, &bdatt->iatt,
-                    valid, NULL);
-
-        return 0;
+bd_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+{
+    int ret = -1;
+    bd_fd_t *bd_fd = NULL;
+    bd_attr_t *bdatt = NULL;
+    int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
+    bd_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(this->private, out);
+
+    ret = bd_inode_ctx_get(fd->inode, this, &bdatt);
+    if (!bdatt)
+        goto out;
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd || !bdatt) {
+        gf_log(this->name, GF_LOG_WARNING, "bdfd/bdatt is NULL from fd=%p", fd);
+        goto out;
+    }
+
+    local = bd_local_init(frame, this);
+    if (!local) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        goto out;
+    }
+
+    local->fd = fd_ref(fd);
+    gf_uuid_copy(loc.gfid, bdatt->iatt.ia_gfid);
+
+    /* Update the a|mtime during flush */
+    STACK_WIND(frame, bd_flush_setattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->setattr, &loc, &bdatt->iatt, valid,
+               NULL);
+
+    return 0;
 
 out:
-        STACK_WIND (frame, default_flush_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->flush, fd, xdata);
+    STACK_WIND(frame, default_flush_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->flush, fd, xdata);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-bd_release (xlator_t *this, fd_t *fd)
+bd_release(xlator_t *this, fd_t *fd)
 {
-        int          ret      = -1;
-        bd_fd_t     *bd_fd    = NULL;
-        uint64_t     tmp_bfd  = 0;
-        bd_attr_t   *bdatt    = NULL;
-        bd_priv_t   *priv     = this->private;
+    int ret = -1;
+    bd_fd_t *bd_fd = NULL;
+    uint64_t tmp_bfd = 0;
+    bd_attr_t *bdatt = NULL;
+    bd_priv_t *priv = this->private;
 
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (priv, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(priv, out);
 
-        ret = bd_inode_ctx_get (fd->inode, this, &bdatt);
-        if (ret || !bdatt) /* posix file */
-                goto out;
+    ret = bd_inode_ctx_get(fd->inode, this, &bdatt);
+    if (ret || !bdatt) /* posix file */
+        goto out;
 
-        /* FIXME: Update amtime during release */
+    /* FIXME: Update amtime during release */
 
-        ret = fd_ctx_del (fd, this, &tmp_bfd);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "bfd is NULL from fd=%p", fd);
-                goto out;
-        }
-        bd_fd = (bd_fd_t *)(long)tmp_bfd;
+    ret = fd_ctx_del(fd, this, &tmp_bfd);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING, "bfd is NULL from fd=%p", fd);
+        goto out;
+    }
+    bd_fd = (bd_fd_t *)(long)tmp_bfd;
 
-        sys_close (bd_fd->fd);
-        GF_FREE (bd_fd);
+    sys_close(bd_fd->fd);
+    GF_FREE(bd_fd);
 out:
-        return 0;
+    return 0;
 }
 
 /*
@@ -900,17 +903,16 @@ out:
  * bd create failure
  */
 int
-bd_setx_rm_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+bd_setx_rm_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xdata)
 {
-        bd_local_t *local = frame->local;
-
-        if (local->fd)
-                BD_STACK_UNWIND (setxattr, frame, -1, EIO, xdata);
-        else
-                BD_STACK_UNWIND (setxattr, frame, -1, EIO, xdata);
-        return 0;
+    bd_local_t *local = frame->local;
 
+    if (local->fd)
+        BD_STACK_UNWIND(setxattr, frame, -1, EIO, xdata);
+    else
+        BD_STACK_UNWIND(setxattr, frame, -1, EIO, xdata);
+    return 0;
 }
 
 /*
@@ -918,426 +920,423 @@ bd_setx_rm_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
  * invokes posix_removexattr to remove created BD_XATTR
  */
 int
-bd_setx_setx_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, dict_t *xdata)
-{
-        bd_local_t *local = frame->local;
-        bd_attr_t  *bdatt = NULL;
-
-        if (op_ret < 0)
-                goto next;
-
-        /* Create LV */
-        op_errno = bd_create (local->inode->gfid, local->bdatt->iatt.ia_size,
-                              local->bdatt->type, this->private);
-        if (!op_errno)
-                goto out;
-
-        /* LV creation failed, remove BD_XATTR */
-        if (local->fd)
-                STACK_WIND (frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->fremovexattr,
-                            local->fd, BD_XATTR, NULL);
-        else
-                STACK_WIND (frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->removexattr,
-                            &local->loc, BD_XATTR, NULL);
-
-        return 0;
+bd_setx_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, dict_t *xdata)
+{
+    bd_local_t *local = frame->local;
+    bd_attr_t *bdatt = NULL;
+
+    if (op_ret < 0)
+        goto next;
+
+    /* Create LV */
+    op_errno = bd_create(local->inode->gfid, local->bdatt->iatt.ia_size,
+                         local->bdatt->type, this->private);
+    if (!op_errno)
+        goto out;
+
+    /* LV creation failed, remove BD_XATTR */
+    if (local->fd)
+        STACK_WIND(frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fremovexattr, local->fd, BD_XATTR,
+                   NULL);
+    else
+        STACK_WIND(frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->removexattr, &local->loc, BD_XATTR,
+                   NULL);
+
+    return 0;
 out:
 
-        bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr);
-        if (!bdatt) {
-                op_ret = -1;
-                op_errno = ENOMEM;
-                goto next;
-        }
+    bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
+    if (!bdatt) {
+        op_ret = -1;
+        op_errno = ENOMEM;
+        goto next;
+    }
 
-        memcpy (&bdatt->iatt, &local->bdatt->iatt, sizeof (struct iatt));
-        bdatt->type = gf_strdup (local->bdatt->type);
+    memcpy(&bdatt->iatt, &local->bdatt->iatt, sizeof(struct iatt));
+    bdatt->type = gf_strdup(local->bdatt->type);
 
-        bd_inode_ctx_set (local->inode, THIS, bdatt);
+    bd_inode_ctx_set(local->inode, THIS, bdatt);
 
 next:
-        if (local->fd)
-                BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
-        else
-                BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
-        return 0;
-
+    if (local->fd)
+        BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    else
+        BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 /*
  * Call back from posix_stat
  */
 int
-bd_setx_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *iatt,
-                  dict_t *xdata)
-{
-        char       *param  = NULL;
-        char       *type   = NULL;
-        char       *s_size = NULL;
-        char       *p      = NULL;
-        char       *copy   = NULL;
-        bd_local_t *local  = frame->local;
-        bd_priv_t  *priv   = this->private;
-        char       *bd     = NULL;
-        uint64_t    size   = 0;
-
-        if (op_ret < 0)
-                goto out;
-
-        if (!IA_ISREG (iatt->ia_type)) {
-                op_errno = EOPNOTSUPP;
-                goto out;
-        }
-
-        param = copy = GF_MALLOC (local->data->len + 1, gf_common_mt_char);
-        BD_VALIDATE_MEM_ALLOC (param, op_errno, out);
-
-        strncpy (param, local->data->data, local->data->len);
-        param[local->data->len] = '\0';
-
-        type = strtok_r (param, ":", &p);
-        if (!type) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        if (strcmp (type, BD_LV) && strcmp (type, BD_THIN)) {
-                gf_log (this->name, GF_LOG_WARNING, "Invalid bd type %s given",
-                        type);
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        if (!strcmp (type, BD_THIN) && !(priv->caps & BD_CAPS_THIN)) {
-                gf_log (this->name, GF_LOG_WARNING, "THIN lv not supported by "
-                        "this volume");
-                op_errno = EOPNOTSUPP;
-                goto out;
-        }
-
-        s_size = strtok_r (NULL, ":", &p);
-
-        /* If size not specified get default size */
-        if (!s_size)
-                size = bd_get_default_extent (priv);
-        else
-                gf_string2bytesize (s_size, &size);
-
-        gf_asprintf (&bd, "%s:%ld", type, size);
-        BD_VALIDATE_MEM_ALLOC (bd, op_errno, out);
-
-        local->dict = dict_new ();
-        BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out);
-
-        local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr);
-        BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out);
-
-        if (dict_set_dynstr (local->dict, BD_XATTR, bd) < 0) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        local->bdatt->type = gf_strdup (type);
-        memcpy (&local->bdatt->iatt, iatt, sizeof (struct iatt));
-        local->bdatt->iatt.ia_size = size;
-
-        if (local->fd)
-                STACK_WIND (frame, bd_setx_setx_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->fsetxattr,
-                            local->fd, local->dict, 0, NULL);
-        else
-                STACK_WIND (frame, bd_setx_setx_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->setxattr,
-                            &local->loc, local->dict, 0, NULL);
-
-        return 0;
+bd_setx_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *iatt, dict_t *xdata)
+{
+    char *param = NULL;
+    char *type = NULL;
+    char *s_size = NULL;
+    char *p = NULL;
+    char *copy = NULL;
+    bd_local_t *local = frame->local;
+    bd_priv_t *priv = this->private;
+    char *bd = NULL;
+    uint64_t size = 0;
+
+    if (op_ret < 0)
+        goto out;
+
+    if (!IA_ISREG(iatt->ia_type)) {
+        op_errno = EOPNOTSUPP;
+        goto out;
+    }
+
+    param = copy = GF_MALLOC(local->data->len + 1, gf_common_mt_char);
+    BD_VALIDATE_MEM_ALLOC(param, op_errno, out);
+
+    strncpy(param, local->data->data, local->data->len);
+    param[local->data->len] = '\0';
+
+    type = strtok_r(param, ":", &p);
+    if (!type) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (strcmp(type, BD_LV) && strcmp(type, BD_THIN)) {
+        gf_log(this->name, GF_LOG_WARNING, "Invalid bd type %s given", type);
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (!strcmp(type, BD_THIN) && !(priv->caps & BD_CAPS_THIN)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "THIN lv not supported by "
+               "this volume");
+        op_errno = EOPNOTSUPP;
+        goto out;
+    }
+
+    s_size = strtok_r(NULL, ":", &p);
+
+    /* If size not specified get default size */
+    if (!s_size)
+        size = bd_get_default_extent(priv);
+    else
+        gf_string2bytesize(s_size, &size);
+
+    gf_asprintf(&bd, "%s:%ld", type, size);
+    BD_VALIDATE_MEM_ALLOC(bd, op_errno, out);
+
+    local->dict = dict_new();
+    BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
+
+    local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
+    BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
+
+    if (dict_set_dynstr(local->dict, BD_XATTR, bd) < 0) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    local->bdatt->type = gf_strdup(type);
+    memcpy(&local->bdatt->iatt, iatt, sizeof(struct iatt));
+    local->bdatt->iatt.ia_size = size;
+
+    if (local->fd)
+        STACK_WIND(frame, bd_setx_setx_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict,
+                   0, NULL);
+    else
+        STACK_WIND(frame, bd_setx_setx_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict,
+                   0, NULL);
+
+    return 0;
 
 out:
-        if (local->fd)
-                BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, xdata);
-        else
-                BD_STACK_UNWIND (setxattr, frame, -1, op_errno, xdata);
+    if (local->fd)
+        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, xdata);
+    else
+        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, xdata);
 
-        GF_FREE (bd);
-        GF_FREE (copy);
-        return 0;
+    GF_FREE(bd);
+    GF_FREE(copy);
+    return 0;
 }
 
 int
-bd_offload_rm_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+bd_offload_rm_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        bd_local_t *local = frame->local;
+    bd_local_t *local = frame->local;
 
-        if (local->fd)
-                BD_STACK_UNWIND (fsetxattr, frame, -1, EIO, NULL);
-        else
-                BD_STACK_UNWIND (setxattr, frame, -1, EIO, NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(fsetxattr, frame, -1, EIO, NULL);
+    else
+        BD_STACK_UNWIND(setxattr, frame, -1, EIO, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_offload_setx_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
+bd_offload_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        bd_local_t *local = frame->local;
+    bd_local_t *local = frame->local;
 
-        if (op_ret < 0)
-                goto out;
+    if (op_ret < 0)
+        goto out;
 
-        if (local->offload == BD_OF_SNAPSHOT)
-                op_ret = bd_snapshot_create (frame->local, this->private);
-        else
-                op_ret = bd_clone (frame->local, this->private);
+    if (local->offload == BD_OF_SNAPSHOT)
+        op_ret = bd_snapshot_create(frame->local, this->private);
+    else
+        op_ret = bd_clone(frame->local, this->private);
 
-        if (op_ret) {
-                STACK_WIND (frame, bd_offload_rm_xattr_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->removexattr,
-                            local->dloc, BD_XATTR, NULL);
-                return 0;
-        }
+    if (op_ret) {
+        STACK_WIND(frame, bd_offload_rm_xattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->removexattr, local->dloc, BD_XATTR,
+                   NULL);
+        return 0;
+    }
 
 out:
-        if (local->fd)
-                BD_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, NULL);
-        else
-                BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL);
+    else
+        BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_offload_getx_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
-{
-        char       *bd    = NULL;
-        bd_local_t *local = frame->local;
-        char       *type  = NULL;
-        char       *p     = NULL;
-
-        if (op_ret < 0)
-                goto out;
-
-        if (dict_get_str (xattr, BD_XATTR, &p)) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        type = gf_strdup (p);
-        BD_VALIDATE_MEM_ALLOC (type, op_errno, out);
-
-        p = strrchr (type, ':');
-        if (!p) {
-                op_errno = EINVAL;
-                gf_log (this->name, GF_LOG_WARNING,
-                        "source file xattr %s corrupted?", type);
-                goto out;
-        }
-
-        *p='\0';
-
-        /* For clone size is taken from source LV */
-        if (!local->size) {
-                p++;
-                gf_string2bytesize (p, &local->size);
-        }
-        gf_asprintf (&bd, "%s:%ld", type, local->size);
-        local->bdatt->type = gf_strdup (type);
-        dict_del (local->dict, LINKTO);
-        if (dict_set_dynstr (local->dict, BD_XATTR, bd)) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        STACK_WIND (frame, bd_offload_setx_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->setxattr,
-                    local->dloc, local->dict, 0, NULL);
-
-        return 0;
+bd_offload_getx_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+{
+    char *bd = NULL;
+    bd_local_t *local = frame->local;
+    char *type = NULL;
+    char *p = NULL;
+
+    if (op_ret < 0)
+        goto out;
+
+    if (dict_get_str(xattr, BD_XATTR, &p)) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    type = gf_strdup(p);
+    BD_VALIDATE_MEM_ALLOC(type, op_errno, out);
+
+    p = strrchr(type, ':');
+    if (!p) {
+        op_errno = EINVAL;
+        gf_log(this->name, GF_LOG_WARNING, "source file xattr %s corrupted?",
+               type);
+        goto out;
+    }
+
+    *p = '\0';
+
+    /* For clone size is taken from source LV */
+    if (!local->size) {
+        p++;
+        gf_string2bytesize(p, &local->size);
+    }
+    gf_asprintf(&bd, "%s:%ld", type, local->size);
+    local->bdatt->type = gf_strdup(type);
+    dict_del(local->dict, LINKTO);
+    if (dict_set_dynstr(local->dict, BD_XATTR, bd)) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    STACK_WIND(frame, bd_offload_setx_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->setxattr, local->dloc, local->dict, 0,
+               NULL);
+
+    return 0;
 
 out:
-        if (local->fd)
-                BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-        else
-                BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+    else
+        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        GF_FREE (type);
-        GF_FREE (bd);
+    GF_FREE(type);
+    GF_FREE(bd);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_offload_dest_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 *xattr, struct iatt *postparent)
-{
-        bd_local_t *local  = frame->local;
-        char       *bd     = NULL;
-        char       *linkto = NULL;
-        int         ret    = -1;
-
-        if (op_ret < 0 && op_errno != ENODATA) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        if (!IA_ISREG (iatt->ia_type)) {
-                op_errno = EINVAL;
-                gf_log (this->name, GF_LOG_WARNING, "destination gfid is not a "
-                        "regular file");
-                goto out;
-        }
-
-        ret = dict_get_str (xattr, LINKTO, &linkto);
-        if (linkto) {
-                op_errno = EINVAL;
-                gf_log (this->name, GF_LOG_WARNING, "destination file not "
-                        "present in same brick");
-                goto out;
-        }
-
-        ret = dict_get_str (xattr, BD_XATTR, &bd);
-        if (bd) {
-                op_errno = EEXIST;
-                goto out;
-        }
-
-        local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr);
-        BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out);
-
-        STACK_WIND (frame, bd_offload_getx_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->getxattr,
-                    &local->loc, BD_XATTR, NULL);
-
-        return 0;
+bd_offload_dest_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 *xattr,
+                           struct iatt *postparent)
+{
+    bd_local_t *local = frame->local;
+    char *bd = NULL;
+    char *linkto = NULL;
+    int ret = -1;
+
+    if (op_ret < 0 && op_errno != ENODATA) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (!IA_ISREG(iatt->ia_type)) {
+        op_errno = EINVAL;
+        gf_log(this->name, GF_LOG_WARNING,
+               "destination gfid is not a "
+               "regular file");
+        goto out;
+    }
+
+    ret = dict_get_str(xattr, LINKTO, &linkto);
+    if (linkto) {
+        op_errno = EINVAL;
+        gf_log(this->name, GF_LOG_WARNING,
+               "destination file not "
+               "present in same brick");
+        goto out;
+    }
+
+    ret = dict_get_str(xattr, BD_XATTR, &bd);
+    if (bd) {
+        op_errno = EEXIST;
+        goto out;
+    }
+
+    local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
+    BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
+
+    STACK_WIND(frame, bd_offload_getx_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->getxattr, &local->loc, BD_XATTR, NULL);
+
+    return 0;
 out:
-        if (local->fd)
-                BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-        else
-                BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+    else
+        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        return (ret == 0) ? 0 : ret;
+    return (ret == 0) ? 0 : ret;
 }
 
 int
-bd_merge_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)
+bd_merge_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)
 {
-        /* FIXME: if delete failed, remove xattr */
+    /* FIXME: if delete failed, remove xattr */
 
-        BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL);
-        return 0;
+    BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL);
+    return 0;
 }
 
 int
 bd_do_merge(call_frame_t *frame, xlator_t *this)
 {
-        bd_local_t *local    = frame->local;
-        inode_t    *parent   = NULL;
-        char       *p        = NULL;
-        int         op_errno = 0;
-
-        op_errno = bd_merge (this->private, local->inode->gfid);
-        if (op_errno)
-                goto out;
-
+    bd_local_t *local = frame->local;
+    inode_t *parent = NULL;
+    char *p = NULL;
+    int op_errno = 0;
+
+    op_errno = bd_merge(this->private, local->inode->gfid);
+    if (op_errno)
+        goto out;
+
+    /*
+     * posix_unlink needs loc->pargfid to be valid, but setxattr FOP does
+     * not have loc->pargfid set. Get parent's gfid by getting parents inode
+     */
+    parent = inode_parent(local->inode, NULL, NULL);
+    if (!parent) {
         /*
-         * posix_unlink needs loc->pargfid to be valid, but setxattr FOP does
-         * not have loc->pargfid set. Get parent's gfid by getting parents inode
+         * FIXME: Snapshot LV already deleted.
+         * remove xattr, instead of returning failure
          */
-        parent = inode_parent (local->inode, NULL, NULL);
-        if (!parent) {
-                /*
-                 * FIXME: Snapshot LV already deleted.
-                 * remove xattr, instead of returning failure
-                 */
-                op_errno = EINVAL;
-                goto out;
-        }
-        gf_uuid_copy (local->loc.pargfid, parent->gfid);
+        op_errno = EINVAL;
+        goto out;
+    }
+    gf_uuid_copy(local->loc.pargfid, parent->gfid);
 
-        p = strrchr (local->loc.path, '/');
-        if (p)
-                p++;
-        local->loc.name = p;
+    p = strrchr(local->loc.path, '/');
+    if (p)
+        p++;
+    local->loc.name = p;
 
-        STACK_WIND (frame, bd_merge_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink,
-                    &local->loc, 0, NULL);
+    STACK_WIND(frame, bd_merge_unlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL);
 
-        return 0;
+    return 0;
 out:
-        BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
+    BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
 
-        return op_errno;
+    return op_errno;
 }
 
 int
-bd_offload (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            fd_t *fd, bd_offload_t offload)
-{
-        char       *param      = NULL;
-        char       *param_copy = NULL;
-        char       *p          = NULL;
-        char       *size       = NULL;
-        char       *gfid       = NULL;
-        int         op_errno   = 0;
-        bd_local_t *local      = frame->local;
-
-        param = GF_MALLOC (local->data->len + 1, gf_common_mt_char);
-        BD_VALIDATE_MEM_ALLOC (param, op_errno, out);
-        param_copy = param;
-
-        local->dict = dict_new ();
-        BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out);
-
-        local->dloc = GF_CALLOC (1, sizeof (loc_t), gf_bd_loc_t);
-        BD_VALIDATE_MEM_ALLOC (local->dloc, op_errno, out);
-
-        strncpy (param, local->data->data, local->data->len);
-        param[local->data->len] = '\0';
-
-        gfid = strtok_r (param, ":", &p);
-        size = strtok_r (NULL, ":", &p);
-        if (size)
-                gf_string2bytesize (size, &local->size);
-        else if (offload != BD_OF_CLONE)
-                local->size = bd_get_default_extent (this->private);
-
-        if (dict_set_int8 (local->dict, BD_XATTR, 1) < 0) {
-                op_errno = EINVAL;
-                goto out;
-        }
-        if (dict_set_int8 (local->dict, LINKTO, 1) < 0) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        gf_uuid_parse (gfid, local->dloc->gfid);
-        local->offload = offload;
-
-        STACK_WIND (frame, bd_offload_dest_lookup_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->lookup, local->dloc,
-                    local->dict);
-
-        return 0;
+bd_offload(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+           bd_offload_t offload)
+{
+    char *param = NULL;
+    char *param_copy = NULL;
+    char *p = NULL;
+    char *size = NULL;
+    char *gfid = NULL;
+    int op_errno = 0;
+    bd_local_t *local = frame->local;
+
+    param = GF_MALLOC(local->data->len + 1, gf_common_mt_char);
+    BD_VALIDATE_MEM_ALLOC(param, op_errno, out);
+    param_copy = param;
+
+    local->dict = dict_new();
+    BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
+
+    local->dloc = GF_CALLOC(1, sizeof(loc_t), gf_bd_loc_t);
+    BD_VALIDATE_MEM_ALLOC(local->dloc, op_errno, out);
+
+    strncpy(param, local->data->data, local->data->len);
+    param[local->data->len] = '\0';
+
+    gfid = strtok_r(param, ":", &p);
+    size = strtok_r(NULL, ":", &p);
+    if (size)
+        gf_string2bytesize(size, &local->size);
+    else if (offload != BD_OF_CLONE)
+        local->size = bd_get_default_extent(this->private);
+
+    if (dict_set_int8(local->dict, BD_XATTR, 1) < 0) {
+        op_errno = EINVAL;
+        goto out;
+    }
+    if (dict_set_int8(local->dict, LINKTO, 1) < 0) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_uuid_parse(gfid, local->dloc->gfid);
+    local->offload = offload;
+
+    STACK_WIND(frame, bd_offload_dest_lookup_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->lookup, local->dloc, local->dict);
+
+    return 0;
 
 out:
-        if (fd)
-                BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-        else
-                BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    if (fd)
+        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+    else
+        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        GF_FREE (param_copy);
-        return 0;
+    GF_FREE(param_copy);
+    return 0;
 }
 
 /*
@@ -1348,71 +1347,70 @@ out:
  * if create_lv failed, posix_removexattr -> bd_setx_rm_xattr_cbk
  */
 int
-bd_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-             int flags, dict_t *xdata)
-{
-        int           op_errno = 0;
-        data_t       *data     = NULL;
-        bd_local_t   *local    = NULL;
-        bd_attr_t    *bdatt    = NULL;
-        bd_offload_t  cl_type  = BD_OF_NONE;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-
-        if ((data = dict_get (dict, BD_XATTR)))
-                cl_type = BD_OF_NONE;
-        else if ((data = dict_get (dict, BD_CLONE)))
-                cl_type = BD_OF_CLONE;
-        else if ((data = dict_get (dict, BD_SNAPSHOT)))
-                cl_type = BD_OF_SNAPSHOT;
-        else if ((data = dict_get (dict, BD_MERGE)))
-                cl_type = BD_OF_MERGE;
-
-        bd_inode_ctx_get (loc->inode, this, &bdatt);
-        if (!cl_type && !data) {
-                STACK_WIND (frame, default_setxattr_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->setxattr, loc, dict,
-                            flags, xdata);
-                return 0;
+bd_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+            int flags, dict_t *xdata)
+{
+    int op_errno = 0;
+    data_t *data = NULL;
+    bd_local_t *local = NULL;
+    bd_attr_t *bdatt = NULL;
+    bd_offload_t cl_type = BD_OF_NONE;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+
+    if ((data = dict_get(dict, BD_XATTR)))
+        cl_type = BD_OF_NONE;
+    else if ((data = dict_get(dict, BD_CLONE)))
+        cl_type = BD_OF_CLONE;
+    else if ((data = dict_get(dict, BD_SNAPSHOT)))
+        cl_type = BD_OF_SNAPSHOT;
+    else if ((data = dict_get(dict, BD_MERGE)))
+        cl_type = BD_OF_MERGE;
+
+    bd_inode_ctx_get(loc->inode, this, &bdatt);
+    if (!cl_type && !data) {
+        STACK_WIND(frame, default_setxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
+        return 0;
+    }
+
+    local = bd_local_init(frame, this);
+    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
+
+    local->data = data;
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+
+    if (cl_type) {
+        /* For cloning/snapshot, source file must be mapped to LV */
+        if (!bdatt) {
+            gf_log(this->name, GF_LOG_WARNING, "%s not mapped to BD",
+                   loc->path);
+            op_errno = EINVAL;
+            goto out;
         }
-
-        local = bd_local_init (frame, this);
-        BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
-
-        local->data = data;
-        loc_copy (&local->loc, loc);
-        local->inode = inode_ref (loc->inode);
-
-        if (cl_type) {
-                /* For cloning/snapshot, source file must be mapped to LV */
-                if (!bdatt) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "%s not mapped to BD", loc->path);
-                        op_errno = EINVAL;
-                        goto out;
-                }
-                if (cl_type == BD_OF_MERGE)
-                        bd_do_merge (frame, this);
-                else
-                        bd_offload (frame, this, loc, NULL, cl_type);
-        } else if (data) {
-                if (bdatt) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "%s already mapped to BD", loc->path);
-                        op_errno = EEXIST;
-                        goto out;
-                }
-                STACK_WIND (frame, bd_setx_stat_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->stat, loc, xdata);
+        if (cl_type == BD_OF_MERGE)
+            bd_do_merge(frame, this);
+        else
+            bd_offload(frame, this, loc, NULL, cl_type);
+    } else if (data) {
+        if (bdatt) {
+            gf_log(this->name, GF_LOG_WARNING, "%s already mapped to BD",
+                   loc->path);
+            op_errno = EEXIST;
+            goto out;
         }
+        STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->stat, loc, xdata);
+    }
 
-        return 0;
+    return 0;
 out:
-        if (op_errno)
-                STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata);
+    if (op_errno)
+        STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -1424,194 +1422,189 @@ out:
  * -> bd_fsetxattr_cbk
  */
 int32_t
-bd_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-              int flags, dict_t *xdata)
-{
-        int           op_errno = 0;
-        data_t       *data     = NULL;
-        bd_attr_t    *bdatt    = NULL;
-        bd_local_t   *local    = NULL;
-        bd_offload_t  cl_type  = BD_OF_NONE;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (this->private, out);
-        VALIDATE_OR_GOTO (fd, out);
-
-        bd_inode_ctx_get (fd->inode, this, &bdatt);
-
-        if ((data = dict_get (dict, BD_XATTR)))
-                cl_type = BD_OF_NONE;
-        else if ((data = dict_get (dict, BD_CLONE)))
-                cl_type = BD_OF_CLONE;
-        else if ((data = dict_get (dict, BD_SNAPSHOT)))
-                cl_type = BD_OF_SNAPSHOT;
-        else if ((data = dict_get (dict, BD_MERGE))) {
-                /*
-                 * bd_merge is not supported for fsetxattr, because snapshot LV
-                 * is opened and it causes problem in snapshot merge
-                 */
-                op_errno = EOPNOTSUPP;
-                goto out;
-        }
-
-        bd_inode_ctx_get (fd->inode, this, &bdatt);
+bd_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+             int flags, dict_t *xdata)
+{
+    int op_errno = 0;
+    data_t *data = NULL;
+    bd_attr_t *bdatt = NULL;
+    bd_local_t *local = NULL;
+    bd_offload_t cl_type = BD_OF_NONE;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(this->private, out);
+    VALIDATE_OR_GOTO(fd, out);
+
+    bd_inode_ctx_get(fd->inode, this, &bdatt);
+
+    if ((data = dict_get(dict, BD_XATTR)))
+        cl_type = BD_OF_NONE;
+    else if ((data = dict_get(dict, BD_CLONE)))
+        cl_type = BD_OF_CLONE;
+    else if ((data = dict_get(dict, BD_SNAPSHOT)))
+        cl_type = BD_OF_SNAPSHOT;
+    else if ((data = dict_get(dict, BD_MERGE))) {
+        /*
+         * bd_merge is not supported for fsetxattr, because snapshot LV
+         * is opened and it causes problem in snapshot merge
+         */
+        op_errno = EOPNOTSUPP;
+        goto out;
+    }
 
-        if (!cl_type && !data) {
-                /* non bd file object */
-                STACK_WIND (frame, default_fsetxattr_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->fsetxattr,
-                            fd, dict, flags, xdata);
-                return 0;
-        }
+    bd_inode_ctx_get(fd->inode, this, &bdatt);
 
-        local = bd_local_init (frame, this);
-        BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
+    if (!cl_type && !data) {
+        /* non bd file object */
+        STACK_WIND(frame, default_fsetxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
+        return 0;
+    }
 
-        local->inode = inode_ref (fd->inode);
-        local->fd = fd_ref (fd);
-        local->data = data;
+    local = bd_local_init(frame, this);
+    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
 
-        if (cl_type) {
-                /* For cloning/snapshot, source file must be mapped to LV */
-                if (!bdatt) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "fd %p not mapped to BD", fd);
-                        op_errno = EINVAL;
-                        goto out;
+    local->inode = inode_ref(fd->inode);
+    local->fd = fd_ref(fd);
+    local->data = data;
 
-                }
-                bd_offload (frame, this, NULL, fd, cl_type);
-        } else if (data) {
-                if (bdatt) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "fd %p already mapped to BD", fd);
-                        op_errno = EEXIST;
-                        goto out;
-                }
-                STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this),
-                           FIRST_CHILD(this)->fops->fstat, fd, xdata);
+    if (cl_type) {
+        /* For cloning/snapshot, source file must be mapped to LV */
+        if (!bdatt) {
+            gf_log(this->name, GF_LOG_WARNING, "fd %p not mapped to BD", fd);
+            op_errno = EINVAL;
+            goto out;
         }
+        bd_offload(frame, this, NULL, fd, cl_type);
+    } else if (data) {
+        if (bdatt) {
+            gf_log(this->name, GF_LOG_WARNING, "fd %p already mapped to BD",
+                   fd);
+            op_errno = EEXIST;
+            goto out;
+        }
+        STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fstat, fd, xdata);
+    }
 
-        return 0;
+    return 0;
 out:
 
-        BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-bd_removexattr (call_frame_t *frame, xlator_t *this,
-                   loc_t *loc, const char *name, dict_t *xdata)
+bd_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+               const char *name, dict_t *xdata)
 {
-        if (!strcmp (name, BD_XATTR))
-            goto out;
+    if (!strcmp(name, BD_XATTR))
+        goto out;
 
-        STACK_WIND (frame, default_removexattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
-        return 0;
+    STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
+    return 0;
 out:
-        BD_STACK_UNWIND (removexattr, frame, -1, ENODATA, NULL);
-        return 0;
+    BD_STACK_UNWIND(removexattr, frame, -1, ENODATA, NULL);
+    return 0;
 }
 
 int32_t
-bd_fremovexattr (call_frame_t *frame, xlator_t *this,
-                    fd_t *fd, const char *name, dict_t *xdata)
+bd_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+                dict_t *xdata)
 {
-        if (!strcmp (name, BD_XATTR))
-            goto out;
+    if (!strcmp(name, BD_XATTR))
+        goto out;
 
-        STACK_WIND (frame, default_removexattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
+    STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
 
-        return 0;
+    return 0;
 out:
-        BD_STACK_UNWIND (fremovexattr, frame, -1, ENODATA, NULL);
-        return 0;
+    BD_STACK_UNWIND(fremovexattr, frame, -1, ENODATA, NULL);
+    return 0;
 }
 
 int
-bd_trunc_setxattr_setx_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
+bd_trunc_setxattr_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, dict_t *xdata)
 {
-        bd_local_t *local = frame->local;
+    bd_local_t *local = frame->local;
 
-        if (local->fd)
-                BD_STACK_UNWIND (ftruncate, frame, -1, EIO, NULL, NULL, NULL);
-        else
-                BD_STACK_UNWIND (truncate, frame, -1, EIO, NULL, NULL, NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(ftruncate, frame, -1, EIO, NULL, NULL, NULL);
+    else
+        BD_STACK_UNWIND(truncate, frame, -1, EIO, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /*
  * Call back for setxattr after setting BD_XATTR_SIZE.
  */
 int
-bd_trunc_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xdata)
+bd_trunc_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata)
 {
-        bd_local_t *local = frame->local;
-        bd_attr_t   *bdatt = NULL;
-        struct iatt prebuf = {0, };
-        char         *bd   = NULL;
+    bd_local_t *local = frame->local;
+    bd_attr_t *bdatt = NULL;
+    struct iatt prebuf = {
+        0,
+    };
+    char *bd = NULL;
 
-        if (op_ret < 0)
-                goto out;
+    if (op_ret < 0)
+        goto out;
 
-        bd_inode_ctx_get (local->inode, this, &bdatt);
-        if (!bdatt)
-                goto revert_xattr;
+    bd_inode_ctx_get(local->inode, this, &bdatt);
+    if (!bdatt)
+        goto revert_xattr;
 
-        op_errno = bd_resize (this->private, local->inode->gfid,
-                              local->bdatt->iatt.ia_size);
-        if (op_errno)
-                goto revert_xattr;
+    op_errno = bd_resize(this->private, local->inode->gfid,
+                         local->bdatt->iatt.ia_size);
+    if (op_errno)
+        goto revert_xattr;
 
-        memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt));
-        /* LV resized, update new size in the cache */
-        bdatt->iatt.ia_size = local->bdatt->iatt.ia_size;
+    memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
+    /* LV resized, update new size in the cache */
+    bdatt->iatt.ia_size = local->bdatt->iatt.ia_size;
 
-        if (local->fd)
-                BD_STACK_UNWIND (ftruncate, frame, 0, 0, &prebuf, &bdatt->iatt,
-                                 NULL);
-        else
-                BD_STACK_UNWIND (truncate, frame, 0, 0, &prebuf, &bdatt->iatt,
-                                 NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(ftruncate, frame, 0, 0, &prebuf, &bdatt->iatt, NULL);
+    else
+        BD_STACK_UNWIND(truncate, frame, 0, 0, &prebuf, &bdatt->iatt, NULL);
 
-        return 0;
+    return 0;
 
 revert_xattr:
-        /* revert setxattr */
-        op_ret = dict_get_str (local->dict, BD_XATTR, &bd);
-        GF_FREE (bd);
-        bd = NULL;
-	if (bdatt)
-		gf_asprintf (&bd, "%s:%ld", bdatt->type, bdatt->iatt.ia_size);
-
-        if (local->fd)
-                STACK_WIND (frame, bd_trunc_setxattr_setx_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->fsetxattr,
-                            local->fd, local->dict, 0, NULL);
-        else
-                STACK_WIND (frame, bd_trunc_setxattr_setx_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->setxattr,
-                            &local->loc, local->dict, 0, NULL);
-
-        if (bd)
-                GF_FREE (bd);
-        return 0;
+    /* revert setxattr */
+    op_ret = dict_get_str(local->dict, BD_XATTR, &bd);
+    GF_FREE(bd);
+    bd = NULL;
+    if (bdatt)
+        gf_asprintf(&bd, "%s:%ld", bdatt->type, bdatt->iatt.ia_size);
+
+    if (local->fd)
+        STACK_WIND(frame, bd_trunc_setxattr_setx_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict,
+                   0, NULL);
+    else
+        STACK_WIND(frame, bd_trunc_setxattr_setx_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict,
+                   0, NULL);
+
+    if (bd)
+        GF_FREE(bd);
+    return 0;
 out:
-        if (local->fd)
-                BD_STACK_UNWIND (ftruncate, frame, -1, EIO, NULL, NULL, NULL);
-        else
-                BD_STACK_UNWIND (truncate, frame, -1, EIO, NULL, NULL, NULL);
+    if (local->fd)
+        BD_STACK_UNWIND(ftruncate, frame, -1, EIO, NULL, NULL, NULL);
+    else
+        BD_STACK_UNWIND(truncate, frame, -1, EIO, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -1621,182 +1614,175 @@ out:
  * the posix file so that truncate fop behaves properly
  */
 int
-bd_trunc_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *buf, dict_t *xdata)
-{
-        char       *bd    = NULL;
-        bd_local_t *local = frame->local;
-        bd_attr_t  *bdatt = NULL;
-
-        if (op_ret < 0)
-                goto out;
-
-        local->dict  = dict_new ();
-        BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out);
-
-        bd_inode_ctx_get (local->inode, this, &bdatt);
-        if (!bdatt) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        gf_asprintf (&bd, "%s:%ld", bdatt->type, local->bdatt->iatt.ia_size);
-        if (dict_set_dynstr (local->dict, BD_XATTR, bd)) {
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        if (local->fd)
-                STACK_WIND (frame, bd_trunc_setxattr_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->fsetxattr,
-                            local->fd, local->dict, 0, NULL);
-        else
-                STACK_WIND (frame, bd_trunc_setxattr_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->setxattr,
-                            &local->loc, local->dict, 0, NULL);
-
-        return 0;
+bd_trunc_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *buf, dict_t *xdata)
+{
+    char *bd = NULL;
+    bd_local_t *local = frame->local;
+    bd_attr_t *bdatt = NULL;
+
+    if (op_ret < 0)
+        goto out;
+
+    local->dict = dict_new();
+    BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
+
+    bd_inode_ctx_get(local->inode, this, &bdatt);
+    if (!bdatt) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_asprintf(&bd, "%s:%ld", bdatt->type, local->bdatt->iatt.ia_size);
+    if (dict_set_dynstr(local->dict, BD_XATTR, bd)) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (local->fd)
+        STACK_WIND(frame, bd_trunc_setxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict,
+                   0, NULL);
+    else
+        STACK_WIND(frame, bd_trunc_setxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict,
+                   0, NULL);
+
+    return 0;
 out:
-        if (local->fd)
-                BD_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL,
-                                 NULL);
-        else
-                BD_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL,
-                                 NULL);
-        GF_FREE (bd);
-        return 0;
+    if (local->fd)
+        BD_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    else
+        BD_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    GF_FREE(bd);
+    return 0;
 }
 
 void
-bd_do_trunc (call_frame_t *frame, xlator_t *this, fd_t *fd, loc_t *loc,
-             off_t offset, bd_attr_t *bdatt)
-{
-        bd_local_t *local    = NULL;
-        struct iatt prebuf   = {0, };
-        int         op_errno = 0;
-        int         op_ret   = -1;
-
-        /* If requested size is less than LV size, return success */
-        if (offset <= bdatt->iatt.ia_size) {
-                memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt));
-                bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME);
-                op_ret = 0;
-                goto out;
-        }
+bd_do_trunc(call_frame_t *frame, xlator_t *this, fd_t *fd, loc_t *loc,
+            off_t offset, bd_attr_t *bdatt)
+{
+    bd_local_t *local = NULL;
+    struct iatt prebuf = {
+        0,
+    };
+    int op_errno = 0;
+    int op_ret = -1;
+
+    /* If requested size is less than LV size, return success */
+    if (offset <= bdatt->iatt.ia_size) {
+        memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
+        bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
+        op_ret = 0;
+        goto out;
+    }
 
-        local = bd_local_init (frame, this);
-        BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
+    local = bd_local_init(frame, this);
+    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
 
-        local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr);
-        BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out);
+    local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
+    BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
 
-        if (fd) {
-                local->inode = inode_ref (fd->inode);
-                local->fd = fd_ref (fd);
-        } else {
-                local->inode = inode_ref (loc->inode);
-                loc_copy (&local->loc, loc);
-        }
+    if (fd) {
+        local->inode = inode_ref(fd->inode);
+        local->fd = fd_ref(fd);
+    } else {
+        local->inode = inode_ref(loc->inode);
+        loc_copy(&local->loc, loc);
+    }
 
-        local->bdatt->iatt.ia_size =
-                bd_adjust_size (this->private, offset);
+    local->bdatt->iatt.ia_size = bd_adjust_size(this->private, offset);
 
-        STACK_WIND (frame, bd_trunc_stat_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fstat, fd, NULL);
+    STACK_WIND(frame, bd_trunc_stat_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fstat, fd, NULL);
 
-        return;
+    return;
 
 out:
-        if (fd)
-                BD_STACK_UNWIND (ftruncate, frame, op_ret, op_errno,
-                                 &prebuf, &bdatt->iatt, NULL);
-        else
-                BD_STACK_UNWIND (truncate, frame, op_ret, op_errno,
-                                 &prebuf, &bdatt->iatt, NULL);
-        return;
+    if (fd)
+        BD_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, &prebuf,
+                        &bdatt->iatt, NULL);
+    else
+        BD_STACK_UNWIND(truncate, frame, op_ret, op_errno, &prebuf,
+                        &bdatt->iatt, NULL);
+    return;
 }
 
 /*
  * bd_ftruncate: Resizes a LV if fd belongs to BD.
  */
 int32_t
-bd_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              dict_t *xdata)
-{
-        int         op_errno = 0;
-        bd_attr_t  *bdatt    = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-
-        if (bd_inode_ctx_get (fd->inode, this, &bdatt)) {
-                STACK_WIND (frame, default_ftruncate_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->ftruncate, fd,
-                            offset, xdata);
-                return 0;
-        }
+bd_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             dict_t *xdata)
+{
+    int op_errno = 0;
+    bd_attr_t *bdatt = NULL;
 
-        bd_do_trunc (frame, this, fd, NULL, offset, bdatt);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+
+    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
+        STACK_WIND(frame, default_ftruncate_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
         return 0;
+    }
+
+    bd_do_trunc(frame, this, fd, NULL, offset, bdatt);
+    return 0;
 out:
-        BD_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /*
  * bd_truncate: Resizes a LV if file maps to LV.
  */
 int32_t
-bd_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-             dict_t *xdata)
+bd_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+            dict_t *xdata)
 {
-        int         op_errno = 0;
-        bd_attr_t  *bdatt    = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (loc, out);
+    int op_errno = 0;
+    bd_attr_t *bdatt = NULL;
 
-        if (bd_inode_ctx_get (loc->inode, this, &bdatt)) {
-                STACK_WIND (frame, default_truncate_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->truncate, loc,
-                            offset, xdata);
-                return 0;
-        }
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(loc, out);
 
-        bd_do_trunc (frame, this, NULL, loc, offset, bdatt);
+    if (bd_inode_ctx_get(loc->inode, this, &bdatt)) {
+        STACK_WIND(frame, default_truncate_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
         return 0;
+    }
+
+    bd_do_trunc(frame, this, NULL, loc, offset, bdatt);
+    return 0;
 
 out:
-        BD_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-__bd_pwritev (int fd, struct iovec *vector, int count, off_t offset,
-              uint64_t bd_size)
-{
-        int        index           = 0;
-        int        retval          = 0;
-
-        if (!vector)
-                return -EFAULT;
-
-        retval = sys_pwritev (fd, vector, count, offset);
-        if (retval == -1) {
-                int64_t off = offset;
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "base %p, length %zd, offset %" PRId64 ", message %s",
-                        vector[index].iov_base, vector[index].iov_len,
-                        off, strerror (errno));
-                retval = -errno;
-                goto err;
-        }
+__bd_pwritev(int fd, struct iovec *vector, int count, off_t offset,
+             uint64_t bd_size)
+{
+    int index = 0;
+    int retval = 0;
+
+    if (!vector)
+        return -EFAULT;
+
+    retval = sys_pwritev(fd, vector, count, offset);
+    if (retval == -1) {
+        int64_t off = offset;
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "base %p, length %zd, offset %" PRId64 ", message %s",
+               vector[index].iov_base, vector[index].iov_len, off,
+               strerror(errno));
+        retval = -errno;
+        goto err;
+    }
 /*
 
 
@@ -1827,7 +1813,7 @@ __bd_pwritev (int fd, struct iovec *vector, int count, off_t offset,
         }
 */
 err:
-        return retval;
+    return retval;
 }
 
 /*
@@ -1835,615 +1821,600 @@ err:
  * bd_writev -> posix_writev -> bd_writev_cbk
  */
 int
-bd_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 *xdict)
-{
-        int32_t         op_ret    = -1;
-        int32_t         op_errno  = 0;
-        int             _fd       = -1;
-        bd_fd_t         *bd_fd    = NULL;
-        int             ret       = -1;
-        uint64_t        size      = 0;
-        struct iatt     prebuf    = {0, };
-        bd_attr_t      *bdatt     = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-        VALIDATE_OR_GOTO (vector, out);
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd) { /* posix fd */
-                STACK_WIND (frame, default_writev_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->writev, fd, vector, count,
-                            offset, flags, iobref, xdict);
-                return 0;
-        }
-
-        _fd = bd_fd->fd;
-
-        if (bd_inode_ctx_get (fd->inode, this, &bdatt)) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-        size = bdatt->iatt.ia_size;
-
-        op_ret = __bd_pwritev (_fd, vector, count, offset, size);
-        if (op_ret < 0) {
-                op_errno = -op_ret;
-                op_ret = -1;
-                gf_log (this->name, GF_LOG_ERROR, "write failed: offset %"PRIu64
-                                ", %s", offset, strerror (op_errno));
-                goto out;
-        }
-
-        memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt));
-        bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME);
+bd_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 *xdict)
+{
+    int32_t op_ret = -1;
+    int32_t op_errno = 0;
+    int _fd = -1;
+    bd_fd_t *bd_fd = NULL;
+    int ret = -1;
+    uint64_t size = 0;
+    struct iatt prebuf = {
+        0,
+    };
+    bd_attr_t *bdatt = NULL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+    VALIDATE_OR_GOTO(vector, out);
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd) { /* posix fd */
+        STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
+                   flags, iobref, xdict);
+        return 0;
+    }
+
+    _fd = bd_fd->fd;
+
+    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+    size = bdatt->iatt.ia_size;
+
+    op_ret = __bd_pwritev(_fd, vector, count, offset, size);
+    if (op_ret < 0) {
+        op_errno = -op_ret;
+        op_ret = -1;
+        gf_log(this->name, GF_LOG_ERROR, "write failed: offset %" PRIu64 ", %s",
+               offset, strerror(op_errno));
+        goto out;
+    }
+
+    memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
+    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
 out:
 
-        BD_STACK_UNWIND (writev, frame, op_ret, op_errno, &prebuf,
-                         &bdatt->iatt, NULL);
-        return 0;
+    BD_STACK_UNWIND(writev, frame, op_ret, op_errno, &prebuf, &bdatt->iatt,
+                    NULL);
+    return 0;
 }
 
 int
-bd_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, struct iatt *prebuf, struct iatt *postbuf,
-                dict_t *xdata)
-{
-        bd_attr_t   *bdatt = NULL;
-        int         *valid = cookie;
-        bd_local_t  *local = frame->local;
-
-        if (op_ret < 0 || !valid || !local)
-                goto out;
-
-        if (bd_inode_ctx_get (local->inode, this, &bdatt))
-                goto out;
-
-        if (*valid & GF_SET_ATTR_UID)
-                bdatt->iatt.ia_uid = postbuf->ia_uid;
-        else if (*valid & GF_SET_ATTR_GID)
-                bdatt->iatt.ia_gid = postbuf->ia_gid;
-        else if (*valid & GF_SET_ATTR_MODE) {
-                bdatt->iatt.ia_type = postbuf->ia_type;
-                bdatt->iatt.ia_prot = postbuf->ia_prot;
-        } else if (*valid & GF_SET_ATTR_ATIME) {
-                bdatt->iatt.ia_atime = postbuf->ia_atime;
-                bdatt->iatt.ia_atime_nsec = postbuf->ia_atime_nsec;
-        } else if (*valid & GF_SET_ATTR_MTIME) {
-                bdatt->iatt.ia_mtime = postbuf->ia_mtime;
-                bdatt->iatt.ia_mtime_nsec = postbuf->ia_mtime_nsec;
-        }
-
-        bdatt->iatt.ia_ctime = postbuf->ia_ctime;
-        bdatt->iatt.ia_ctime_nsec = postbuf->ia_ctime_nsec;
-
-        memcpy (postbuf, &bdatt->iatt, sizeof (struct iatt));
+bd_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+               dict_t *xdata)
+{
+    bd_attr_t *bdatt = NULL;
+    int *valid = cookie;
+    bd_local_t *local = frame->local;
+
+    if (op_ret < 0 || !valid || !local)
+        goto out;
+
+    if (bd_inode_ctx_get(local->inode, this, &bdatt))
+        goto out;
+
+    if (*valid & GF_SET_ATTR_UID)
+        bdatt->iatt.ia_uid = postbuf->ia_uid;
+    else if (*valid & GF_SET_ATTR_GID)
+        bdatt->iatt.ia_gid = postbuf->ia_gid;
+    else if (*valid & GF_SET_ATTR_MODE) {
+        bdatt->iatt.ia_type = postbuf->ia_type;
+        bdatt->iatt.ia_prot = postbuf->ia_prot;
+    } else if (*valid & GF_SET_ATTR_ATIME) {
+        bdatt->iatt.ia_atime = postbuf->ia_atime;
+        bdatt->iatt.ia_atime_nsec = postbuf->ia_atime_nsec;
+    } else if (*valid & GF_SET_ATTR_MTIME) {
+        bdatt->iatt.ia_mtime = postbuf->ia_mtime;
+        bdatt->iatt.ia_mtime_nsec = postbuf->ia_mtime_nsec;
+    }
+
+    bdatt->iatt.ia_ctime = postbuf->ia_ctime;
+    bdatt->iatt.ia_ctime_nsec = postbuf->ia_ctime_nsec;
+
+    memcpy(postbuf, &bdatt->iatt, sizeof(struct iatt));
 out:
-        GF_FREE (valid);
-        BD_STACK_UNWIND (setattr, frame, op_ret, op_errno, prebuf,
-                         postbuf, xdata);
-        return 0;
+    GF_FREE(valid);
+    BD_STACK_UNWIND(setattr, frame, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
 int
-bd_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
-            int32_t valid, dict_t *xdata)
-{
-        bd_local_t *local     = NULL;
-        bd_attr_t  *bdatt     = NULL;
-        int        *ck_valid  = NULL;
-
-        if (bd_inode_ctx_get (loc->inode, this, &bdatt)) {
-                STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
-                           FIRST_CHILD(this)->fops->setattr,
-                           loc, stbuf, valid, xdata);
-                return 0;
-        }
-
-        local = bd_local_init (frame, this);
-        if (!local) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                goto out;
-        }
-
-        ck_valid = GF_CALLOC (1, sizeof (valid), gf_bd_int32_t);
-        if (!ck_valid) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                goto out;
-        }
-
-        local->inode = inode_ref (loc->inode);
-        *ck_valid = valid;
-
-        STACK_WIND_COOKIE (frame, bd_setattr_cbk, ck_valid, FIRST_CHILD(this),
-                           FIRST_CHILD(this)->fops->setattr,
-                           loc, stbuf, valid, xdata);
-        GF_FREE (ck_valid);
-        return 0;
+bd_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
+           int32_t valid, dict_t *xdata)
+{
+    bd_local_t *local = NULL;
+    bd_attr_t *bdatt = NULL;
+    int *ck_valid = NULL;
+
+    if (bd_inode_ctx_get(loc->inode, this, &bdatt)) {
+        STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
+        return 0;
+    }
+
+    local = bd_local_init(frame, this);
+    if (!local) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        goto out;
+    }
+
+    ck_valid = GF_CALLOC(1, sizeof(valid), gf_bd_int32_t);
+    if (!ck_valid) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        goto out;
+    }
+
+    local->inode = inode_ref(loc->inode);
+    *ck_valid = valid;
+
+    STACK_WIND_COOKIE(frame, bd_setattr_cbk, ck_valid, FIRST_CHILD(this),
+                      FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid,
+                      xdata);
+    GF_FREE(ck_valid);
+    return 0;
 out:
-        BD_STACK_UNWIND (setattr, frame, -1, ENOMEM, NULL, NULL, xdata);
-        return 0;
+    BD_STACK_UNWIND(setattr, frame, -1, ENOMEM, NULL, NULL, xdata);
+    return 0;
 }
 
 int
-bd_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+bd_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+            int op_errno, inode_t *inode, struct iatt *buf,
+            struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        bd_attr_t *bdatt = NULL;
+    bd_attr_t *bdatt = NULL;
 
-        if (op_ret < 0)
-                goto out;
+    if (op_ret < 0)
+        goto out;
 
-        if (bd_inode_ctx_get (inode, this, &bdatt))
-                goto out;
+    if (bd_inode_ctx_get(inode, this, &bdatt))
+        goto out;
 
-        bdatt->iatt.ia_ctime = buf->ia_ctime;
-        bdatt->iatt.ia_ctime_nsec = buf->ia_ctime_nsec;
-        bdatt->iatt.ia_nlink = buf->ia_nlink;
-        memcpy (buf, &bdatt->iatt, sizeof (struct iatt));
+    bdatt->iatt.ia_ctime = buf->ia_ctime;
+    bdatt->iatt.ia_ctime_nsec = buf->ia_ctime_nsec;
+    bdatt->iatt.ia_nlink = buf->ia_nlink;
+    memcpy(buf, &bdatt->iatt, sizeof(struct iatt));
 
 out:
-        BD_STACK_UNWIND (link, frame, op_ret, op_errno, inode, buf,
-                         preparent, postparent, NULL);
-        return 0;
+    BD_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent,
+                    postparent, NULL);
+    return 0;
 }
 
 int
-bd_link (call_frame_t *frame, xlator_t *this,
-         loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+bd_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+        dict_t *xdata)
 {
-        STACK_WIND (frame, bd_link_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
-        return 0;
+    STACK_WIND(frame, bd_link_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
+    return 0;
 }
 
 int
-bd_handle_special_xattrs (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                          fd_t *fd, const char *name, dict_t *xdata)
-{
-        dict_t *xattr   = NULL;
-        int op_ret      = -1;
-        int op_errno    = ENOMEM;;
-        bd_priv_t *priv = this->private;
-
-        xattr = dict_new ();
-        if (!xattr)
-                goto out;
-
-        if (!strcmp (name, VOL_TYPE))
-                op_ret = dict_set_int64 (xattr, (char *)name, 1);
-        else if (!strcmp (name, VOL_CAPS))
-                op_ret = dict_set_int64 (xattr, (char *)name, priv->caps);
-        else
-                op_ret = bd_get_origin (this->private, loc, fd, xattr);
+bd_handle_special_xattrs(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                         fd_t *fd, const char *name, dict_t *xdata)
+{
+    dict_t *xattr = NULL;
+    int op_ret = -1;
+    int op_errno = ENOMEM;
+    ;
+    bd_priv_t *priv = this->private;
+
+    xattr = dict_new();
+    if (!xattr)
+        goto out;
+
+    if (!strcmp(name, VOL_TYPE))
+        op_ret = dict_set_int64(xattr, (char *)name, 1);
+    else if (!strcmp(name, VOL_CAPS))
+        op_ret = dict_set_int64(xattr, (char *)name, priv->caps);
+    else
+        op_ret = bd_get_origin(this->private, loc, fd, xattr);
 
 out:
-        if (loc)
-                BD_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr,
-                                 xdata);
-        else
-                BD_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, xattr,
-                                 xdata);
+    if (loc)
+        BD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
+    else
+        BD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata);
 
-        op_ret = dict_reset (xattr);
-        dict_unref (xattr);
+    op_ret = dict_reset(xattr);
+    dict_unref(xattr);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_fgetxattr (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, const char *name, dict_t *xdata)
+bd_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+             dict_t *xdata)
 {
-        if (name && (!strcmp (name, VOL_TYPE) || !strcmp (name, VOL_CAPS)
-                     || !strcmp (name, BD_ORIGIN)))
-                bd_handle_special_xattrs (frame, this, NULL, fd, name, xdata);
-        else
-                STACK_WIND (frame, default_fgetxattr_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->fgetxattr,
-                            fd, name, xdata);
-        return 0;
+    if (name && (!strcmp(name, VOL_TYPE) || !strcmp(name, VOL_CAPS) ||
+                 !strcmp(name, BD_ORIGIN)))
+        bd_handle_special_xattrs(frame, this, NULL, fd, name, xdata);
+    else
+        STACK_WIND(frame, default_fgetxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
+    return 0;
 }
 
 int
-bd_getxattr (call_frame_t *frame, xlator_t *this,
-             loc_t *loc, const char *name, dict_t *xdata)
+bd_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+            dict_t *xdata)
 {
-        if (name && (!strcmp (name, VOL_TYPE) || !strcmp (name, VOL_CAPS)
-                     || !strcmp (name, BD_ORIGIN)))
-                bd_handle_special_xattrs (frame, this, loc, NULL, name, xdata);
-        else
-                STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->getxattr,
-                            loc, name, xdata);
+    if (name && (!strcmp(name, VOL_TYPE) || !strcmp(name, VOL_CAPS) ||
+                 !strcmp(name, BD_ORIGIN)))
+        bd_handle_special_xattrs(frame, this, loc, NULL, name, xdata);
+    else
+        STACK_WIND(frame, default_getxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-bd_unlink_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, inode_t *inode,
-                      struct iatt *buf, dict_t *xattr,
-                      struct iatt *postparent)
+bd_unlink_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
+                     dict_t *xattr, struct iatt *postparent)
 {
-        bd_gfid_t     gfid  = {0, };
-        bd_local_t   *local = frame->local;
+    bd_gfid_t gfid = {
+        0,
+    };
+    bd_local_t *local = frame->local;
 
-        if (buf->ia_nlink > 1)
-                goto posix;
+    if (buf->ia_nlink > 1)
+        goto posix;
 
-        BD_VALIDATE_LOCAL_OR_GOTO (local, op_errno, out);
+    BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out);
 
-        uuid_utoa_r (inode->gfid, gfid);
-        if (bd_delete_lv (this->private, gfid, &op_errno) < 0) {
-                if (op_errno != ENOENT)
-                        goto out;
-        }
+    uuid_utoa_r(inode->gfid, gfid);
+    if (bd_delete_lv(this->private, gfid, &op_errno) < 0) {
+        if (op_errno != ENOENT)
+            goto out;
+    }
 
 posix:
-        /* remove posix */
-        STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink,
-                    &local->loc, 0, NULL);
+    /* remove posix */
+    STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL);
 
-        return 0;
+    return 0;
 out:
-        BD_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-bd_unlink (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, int xflag, dict_t *xdata)
-{
-        int          op_errno = 0;
-        bd_attr_t   *bdatt     = NULL;
-        bd_local_t  *local     = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (loc, out);
-
-        if (bd_inode_ctx_get (loc->inode, this, &bdatt)) {
-                STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->unlink,
-                            loc, xflag, xdata);
-                return 0;
-        }
-
-        local = bd_local_init (frame, this);
-        BD_VALIDATE_MEM_ALLOC (local, op_errno, out);
+bd_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+          dict_t *xdata)
+{
+    int op_errno = 0;
+    bd_attr_t *bdatt = NULL;
+    bd_local_t *local = NULL;
 
-        loc_copy (&local->loc, loc);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(loc, out);
 
-        STACK_WIND (frame, bd_unlink_lookup_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->lookup, loc, NULL);
+    if (bd_inode_ctx_get(loc->inode, this, &bdatt)) {
+        STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
         return 0;
+    }
+
+    local = bd_local_init(frame, this);
+    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
+
+    loc_copy(&local->loc, loc);
+
+    STACK_WIND(frame, bd_unlink_lookup_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->lookup, loc, NULL);
+    return 0;
 out:
-        BD_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    BD_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-bd_priv (xlator_t *this)
+bd_priv(xlator_t *this)
 {
-        return 0;
+    return 0;
 }
 
 int32_t
-bd_inode (xlator_t *this)
+bd_inode(xlator_t *this)
 {
-        return 0;
+    return 0;
 }
 
 int32_t
-bd_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              int32_t len, dict_t *xdata)
-{
-        int             op_ret          = -1;
-        int             op_errno        = 0;
-        int             ret             = 0;
-        int             _fd             = -1;
-        char           *alloc_buf       = NULL;
-        char           *buf             = NULL;
-        int32_t         weak_checksum   = 0;
-        bd_fd_t        *bd_fd           = NULL;
-        unsigned char   strong_checksum[SHA256_DIGEST_LENGTH] = {0};
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (this, out);
-        VALIDATE_OR_GOTO (fd, out);
-
-        ret = bd_fd_ctx_get (this, fd, &bd_fd);
-        if (ret < 0 || !bd_fd) {
-                STACK_WIND (frame, default_rchecksum_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->rchecksum, fd, offset,
-                            len, xdata);
-                return 0;
-        }
-
-        alloc_buf = page_aligned_alloc (len, &buf);
-        if (!alloc_buf) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        _fd = bd_fd->fd;
-
-        LOCK (&fd->lock);
-        {
-                ret = sys_pread (_fd, buf, len, offset);
-                if (ret < 0) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "pread of %d bytes returned %d (%s)",
-                                len, ret, strerror (errno));
-                        op_errno = errno;
-                }
+bd_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             int32_t len, dict_t *xdata)
+{
+    int op_ret = -1;
+    int op_errno = 0;
+    int ret = 0;
+    int _fd = -1;
+    char *alloc_buf = NULL;
+    char *buf = NULL;
+    int32_t weak_checksum = 0;
+    bd_fd_t *bd_fd = NULL;
+    unsigned char strong_checksum[SHA256_DIGEST_LENGTH] = {0};
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(this, out);
+    VALIDATE_OR_GOTO(fd, out);
+
+    ret = bd_fd_ctx_get(this, fd, &bd_fd);
+    if (ret < 0 || !bd_fd) {
+        STACK_WIND(frame, default_rchecksum_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata);
+        return 0;
+    }
+
+    alloc_buf = page_aligned_alloc(len, &buf);
+    if (!alloc_buf) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    _fd = bd_fd->fd;
+
+    LOCK(&fd->lock);
+    {
+        ret = sys_pread(_fd, buf, len, offset);
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "pread of %d bytes returned %d (%s)", len, ret,
+                   strerror(errno));
+            op_errno = errno;
         }
-        UNLOCK (&fd->lock);
+    }
+    UNLOCK(&fd->lock);
 
-        if (ret < 0)
-                goto out;
+    if (ret < 0)
+        goto out;
 
-        weak_checksum = gf_rsync_weak_checksum ((unsigned char *) buf,
-                                                (size_t) len);
-        gf_rsync_strong_checksum ((unsigned char *) buf, (size_t) len,
-                                  (unsigned char *) strong_checksum);
+    weak_checksum = gf_rsync_weak_checksum((unsigned char *)buf, (size_t)len);
+    gf_rsync_strong_checksum((unsigned char *)buf, (size_t)len,
+                             (unsigned char *)strong_checksum);
 
-        op_ret = 0;
+    op_ret = 0;
 out:
-        BD_STACK_UNWIND (rchecksum, frame, op_ret, op_errno,
-                         weak_checksum, strong_checksum, NULL);
+    BD_STACK_UNWIND(rchecksum, frame, op_ret, op_errno, weak_checksum,
+                    strong_checksum, NULL);
 
-        GF_FREE (alloc_buf);
+    GF_FREE(alloc_buf);
 
-        return 0;
+    return 0;
 }
 
 static int
 bd_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
             off_t len, dict_t *xdata)
 {
-        int32_t ret             =  0;
-        struct  iatt statpre    = {0,};
-        struct  iatt statpost   = {0,};
-        bd_attr_t *bdatt = NULL;
-
-        /* iatt already cached */
-        if (bd_inode_ctx_get (fd->inode, this, &bdatt) < 0) {
-                STACK_WIND (frame, default_zerofill_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->zerofill,
-                            fd, offset, len, xdata);
-                return 0;
-        }
-
-        ret = bd_do_zerofill(frame, this, fd, offset, len,
-                             &statpre, &statpost);
-        if (ret)
-                goto err;
+    int32_t ret = 0;
+    struct iatt statpre = {
+        0,
+    };
+    struct iatt statpost = {
+        0,
+    };
+    bd_attr_t *bdatt = NULL;
 
-        STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, NULL);
+    /* iatt already cached */
+    if (bd_inode_ctx_get(fd->inode, this, &bdatt) < 0) {
+        STACK_WIND(frame, default_zerofill_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata);
         return 0;
+    }
+
+    ret = bd_do_zerofill(frame, this, fd, offset, len, &statpre, &statpost);
+    if (ret)
+        goto err;
+
+    STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, NULL);
+    return 0;
 
 err:
-        STACK_UNWIND_STRICT(zerofill, frame, -1, (ret == -1 ? 0 : ret),
-                            NULL, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(zerofill, frame, -1, (ret == -1 ? 0 : ret), NULL, NULL,
+                        NULL);
+    return 0;
 }
 
 /**
  * notify - when parent sends PARENT_UP, send CHILD_UP event from here
  */
 int32_t
-notify (xlator_t *this,
-        int32_t event,
-        void *data,
-        ...)
-{
-        switch (event)
-        {
-        case GF_EVENT_PARENT_UP:
-        {
-                /* Tell the parent that bd xlator is up */
-                default_notify (this, GF_EVENT_CHILD_UP, data);
-        }
-        break;
+notify(xlator_t *this, int32_t event, void *data, ...)
+{
+    switch (event) {
+        case GF_EVENT_PARENT_UP: {
+            /* Tell the parent that bd xlator is up */
+            default_notify(this, GF_EVENT_CHILD_UP, data);
+        } break;
         default:
-                break;
-        }
-        return 0;
+            break;
+    }
+    return 0;
 }
 
 int32_t
-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, gf_bd_mt_end + 1);
+    ret = xlator_mem_acct_init(this, gf_bd_mt_end + 1);
 
-        if (ret != 0)
-                gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                       "failed");
+    if (ret != 0)
+        gf_log(this->name, GF_LOG_ERROR,
+               "Memory accounting init"
+               "failed");
 
-        return ret;
+    return ret;
 }
 
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
-        int   ret = -1;
-        bd_priv_t *priv = this->private;
+    int ret = -1;
+    bd_priv_t *priv = this->private;
 
-        GF_OPTION_RECONF ("bd-aio", priv->aio_configured, options,
-                          bool, out);
+    GF_OPTION_RECONF("bd-aio", priv->aio_configured, options, bool, out);
 
-        if (priv->aio_configured)
-                bd_aio_on (this);
-        else
-                bd_aio_off (this);
+    if (priv->aio_configured)
+        bd_aio_on(this);
+    else
+        bd_aio_off(this);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
  * bd xlator init - Validate configured VG
  */
 int
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        char       *vg_data     = NULL;
-        char       *device      = NULL;
-        bd_priv_t  *_private    = NULL;
+    char *vg_data = NULL;
+    char *device = NULL;
+    bd_priv_t *_private = NULL;
 
-        if (!this->children) {
-                gf_log (this->name, GF_LOG_CRITICAL,
-                        "FATAL: storage/bd needs posix as subvolume");
-                return -1;
-        }
+    if (!this->children) {
+        gf_log(this->name, GF_LOG_CRITICAL,
+               "FATAL: storage/bd needs posix as subvolume");
+        return -1;
+    }
 
-        if (!this->parents) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Volume is dangling. Please check the volume file.");
-        }
+    if (!this->parents) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "Volume is dangling. Please check the volume file.");
+    }
 
-        GF_OPTION_INIT ("export", vg_data, str, error);
-        GF_OPTION_INIT ("device", device, str, error);
+    GF_OPTION_INIT("export", vg_data, str, error);
+    GF_OPTION_INIT("device", device, str, error);
 
-        /* Now we support only LV device */
-        if (strcasecmp (device, BACKEND_VG)) {
-                gf_log (this->name, GF_LOG_CRITICAL,
-                        "FATAL: unknown %s backend %s", BD_XLATOR, device);
-                return -1;
-        }
+    /* Now we support only LV device */
+    if (strcasecmp(device, BACKEND_VG)) {
+        gf_log(this->name, GF_LOG_CRITICAL, "FATAL: unknown %s backend %s",
+               BD_XLATOR, device);
+        return -1;
+    }
 
-        this->local_pool = mem_pool_new (bd_local_t, 64);
-        if (!this->local_pool) {
-                gf_log (this->name, GF_LOG_CRITICAL,
-                        "FATAL: Failed to create bd memory pool");
-                return -1;
-        }
+    this->local_pool = mem_pool_new(bd_local_t, 64);
+    if (!this->local_pool) {
+        gf_log(this->name, GF_LOG_CRITICAL,
+               "FATAL: Failed to create bd memory pool");
+        return -1;
+    }
 
-        _private = GF_CALLOC (1, sizeof (*_private), gf_bd_private);
-        if (!_private)
-                goto error;
+    _private = GF_CALLOC(1, sizeof(*_private), gf_bd_private);
+    if (!_private)
+        goto error;
 
-        this->private = _private;
-        _private->vg = gf_strdup (vg_data);
-        if (!_private->vg)
-                goto error;
+    this->private = _private;
+    _private->vg = gf_strdup(vg_data);
+    if (!_private->vg)
+        goto error;
 
-        _private->handle = lvm_init (NULL);
-        if (!_private->handle) {
-                gf_log (this->name, GF_LOG_CRITICAL, "lvm_init failed");
-                goto error;
-        }
-        _private->caps = BD_CAPS_BD;
-        if (bd_scan_vg (this, _private))
-                goto error;
-
-        _private->aio_init_done = _gf_false;
-        _private->aio_capable = _gf_false;
-
-        GF_OPTION_INIT ("bd-aio", _private->aio_configured, bool, error);
-        if (_private->aio_configured) {
-                if (bd_aio_on (this)) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "BD AIO init failed");
-                        goto error;
-                }
+    _private->handle = lvm_init(NULL);
+    if (!_private->handle) {
+        gf_log(this->name, GF_LOG_CRITICAL, "lvm_init failed");
+        goto error;
+    }
+    _private->caps = BD_CAPS_BD;
+    if (bd_scan_vg(this, _private))
+        goto error;
+
+    _private->aio_init_done = _gf_false;
+    _private->aio_capable = _gf_false;
+
+    GF_OPTION_INIT("bd-aio", _private->aio_configured, bool, error);
+    if (_private->aio_configured) {
+        if (bd_aio_on(this)) {
+            gf_log(this->name, GF_LOG_ERROR, "BD AIO init failed");
+            goto error;
         }
+    }
 
-        _private->caps |= BD_CAPS_OFFLOAD_COPY | BD_CAPS_OFFLOAD_SNAPSHOT |
-                BD_CAPS_OFFLOAD_ZERO;
+    _private->caps |= BD_CAPS_OFFLOAD_COPY | BD_CAPS_OFFLOAD_SNAPSHOT |
+                      BD_CAPS_OFFLOAD_ZERO;
 
-        return 0;
+    return 0;
 error:
-        if (_private) {
-                GF_FREE (_private->vg);
-                if (_private->handle)
-                        lvm_quit (_private->handle);
-                GF_FREE (_private);
-        }
+    if (_private) {
+        GF_FREE(_private->vg);
+        if (_private->handle)
+            lvm_quit(_private->handle);
+        GF_FREE(_private);
+    }
 
-        mem_pool_destroy (this->local_pool);
+    mem_pool_destroy(this->local_pool);
 
-        return -1;
+    return -1;
 }
 
 void
-fini (xlator_t *this)
-{
-        bd_priv_t *priv = this->private;
-        mem_pool_destroy (this->local_pool);
-        this->local_pool = NULL;
-        if (!priv)
-                return;
-        lvm_quit (priv->handle);
-        GF_FREE (priv->vg);
-        this->private = NULL;
-        GF_FREE (priv);
+fini(xlator_t *this)
+{
+    bd_priv_t *priv = this->private;
+    mem_pool_destroy(this->local_pool);
+    this->local_pool = NULL;
+    if (!priv)
         return;
+    lvm_quit(priv->handle);
+    GF_FREE(priv->vg);
+    this->private = NULL;
+    GF_FREE(priv);
+    return;
 }
 
 struct xlator_dumpops dumpops = {
-        .priv    = bd_priv,
-        .inode   = bd_inode,
+    .priv = bd_priv,
+    .inode = bd_inode,
 };
 
 struct xlator_fops fops = {
-        .readdirp    = bd_readdirp,
-        .lookup      = bd_lookup,
-        .stat        = bd_stat,
-        .statfs      = bd_statfs,
-        .open        = bd_open,
-        .fstat       = bd_fstat,
-        .rchecksum   = bd_rchecksum,
-        .readv       = bd_readv,
-        .fsync       = bd_fsync,
-        .setxattr    = bd_setxattr,
-        .fsetxattr   = bd_fsetxattr,
-        .removexattr = bd_removexattr,
-        .fremovexattr=bd_fremovexattr,
-        .truncate    = bd_truncate,
-        .ftruncate   = bd_ftruncate,
-        .writev      = bd_writev,
-        .getxattr    = bd_getxattr,
-        .fgetxattr   = bd_fgetxattr,
-        .unlink      = bd_unlink,
-        .link        = bd_link,
-        .flush       = bd_flush,
-        .setattr     = bd_setattr,
-        .discard     = bd_discard,
-        .zerofill    = bd_zerofill,
+    .readdirp = bd_readdirp,
+    .lookup = bd_lookup,
+    .stat = bd_stat,
+    .statfs = bd_statfs,
+    .open = bd_open,
+    .fstat = bd_fstat,
+    .rchecksum = bd_rchecksum,
+    .readv = bd_readv,
+    .fsync = bd_fsync,
+    .setxattr = bd_setxattr,
+    .fsetxattr = bd_fsetxattr,
+    .removexattr = bd_removexattr,
+    .fremovexattr = bd_fremovexattr,
+    .truncate = bd_truncate,
+    .ftruncate = bd_ftruncate,
+    .writev = bd_writev,
+    .getxattr = bd_getxattr,
+    .fgetxattr = bd_fgetxattr,
+    .unlink = bd_unlink,
+    .link = bd_link,
+    .flush = bd_flush,
+    .setattr = bd_setattr,
+    .discard = bd_discard,
+    .zerofill = bd_zerofill,
 };
 
 struct xlator_cbks cbks = {
-        .release     = bd_release,
-        .forget      = bd_forget,
+    .release = bd_release,
+    .forget = bd_forget,
 };
 
 struct volume_options options[] = {
-        { .key = {"export"},
-          .type = GF_OPTION_TYPE_STR},
-        { .key = {"device"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = BACKEND_VG},
-        {
-          .key  = {"bd-aio"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Support for native Linux AIO"
-        },
-
-        { .key = {NULL} }
-};
+    {.key = {"export"}, .type = GF_OPTION_TYPE_STR},
+    {.key = {"device"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = BACKEND_VG},
+    {.key = {"bd-aio"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Support for native Linux AIO"},
+
+    {.key = {NULL}}};