Land part 2 of clang-format changes

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

2 files changed, 1738 insertions, 1864 deletions

diff --git a/xlators/system/posix-acl/src/posix-acl-xattr.c b/xlators/system/posix-acl/src/posix-acl-xattr.c
index 3c8826568ca..73f22dabc3d 100644
--- a/xlators/system/posix-acl/src/posix-acl-xattr.c
+++ b/xlators/system/posix-acl/src/posix-acl-xattr.c
@@ -14,167 +14,160 @@
 #include "posix-acl.h"
 #include "posix-acl-xattr.h"
 
-
 int
-posix_ace_cmp (const void *val1, const void *val2)
+posix_ace_cmp(const void *val1, const void *val2)
 {
-        const struct posix_ace *ace1 = NULL;
-        const struct posix_ace *ace2 = NULL;
-        int                     ret = 0;
+    const struct posix_ace *ace1 = NULL;
+    const struct posix_ace *ace2 = NULL;
+    int ret = 0;
 
-        ace1 = val1;
-        ace2 = val2;
+    ace1 = val1;
+    ace2 = val2;
 
-        ret = (ace1->tag - ace2->tag);
-        if (!ret)
-                ret = (ace1->id - ace2->id);
+    ret = (ace1->tag - ace2->tag);
+    if (!ret)
+        ret = (ace1->id - ace2->id);
 
-        return ret;
+    return ret;
 }
 
-
 void
-posix_acl_normalize (xlator_t *this, struct posix_acl *acl)
+posix_acl_normalize(xlator_t *this, struct posix_acl *acl)
 {
-        qsort (acl->entries, acl->count, sizeof (struct posix_ace *),
-               posix_ace_cmp);
+    qsort(acl->entries, acl->count, sizeof(struct posix_ace *), posix_ace_cmp);
 }
 
-
 struct posix_acl *
-posix_acl_from_xattr (xlator_t *this, const char *xattr_buf, int xattr_size)
+posix_acl_from_xattr(xlator_t *this, const char *xattr_buf, int xattr_size)
 {
-        struct posix_acl_xattr_header   *header = NULL;
-        struct posix_acl_xattr_entry    *entry = NULL;
-        struct posix_acl                *acl = NULL;
-        struct posix_ace                *ace = NULL;
-        int                              size = 0;
-        int                              count = 0;
-        int                              i = 0;
+    struct posix_acl_xattr_header *header = NULL;
+    struct posix_acl_xattr_entry *entry = NULL;
+    struct posix_acl *acl = NULL;
+    struct posix_ace *ace = NULL;
+    int size = 0;
+    int count = 0;
+    int i = 0;
 
-        size = xattr_size;
+    size = xattr_size;
 
-        if (size < sizeof (*header))
-                return NULL;
-
-        size -= sizeof (*header);
+    if (size < sizeof(*header))
+        return NULL;
 
-        if (size % sizeof (*entry))
-                return NULL;
+    size -= sizeof(*header);
 
-        count = size / sizeof (*entry);
+    if (size % sizeof(*entry))
+        return NULL;
 
-        header = (struct posix_acl_xattr_header *) (xattr_buf);
-        entry  = (struct posix_acl_xattr_entry *) (header + 1);
+    count = size / sizeof(*entry);
 
-        if (header->version != htole32 (POSIX_ACL_XATTR_VERSION))
-                return NULL;
+    header = (struct posix_acl_xattr_header *)(xattr_buf);
+    entry = (struct posix_acl_xattr_entry *)(header + 1);
 
-        acl = posix_acl_new (this, count);
-        if (!acl)
-                return NULL;
+    if (header->version != htole32(POSIX_ACL_XATTR_VERSION))
+        return NULL;
 
-        ace = acl->entries;
+    acl = posix_acl_new(this, count);
+    if (!acl)
+        return NULL;
 
-        for (i = 0; i < count; i++) {
-                ace->tag  = letoh16 (entry->tag);
-                ace->perm = letoh16 (entry->perm);
+    ace = acl->entries;
 
-                switch (ace->tag) {
-                case POSIX_ACL_USER_OBJ:
-                case POSIX_ACL_MASK:
-                case POSIX_ACL_OTHER:
-                        ace->id = POSIX_ACL_UNDEFINED_ID;
-                        break;
+    for (i = 0; i < count; i++) {
+        ace->tag = letoh16(entry->tag);
+        ace->perm = letoh16(entry->perm);
 
-                case POSIX_ACL_GROUP:
-                case POSIX_ACL_USER:
-                case POSIX_ACL_GROUP_OBJ:
-                        ace->id = letoh32 (entry->id);
-                        break;
+        switch (ace->tag) {
+            case POSIX_ACL_USER_OBJ:
+            case POSIX_ACL_MASK:
+            case POSIX_ACL_OTHER:
+                ace->id = POSIX_ACL_UNDEFINED_ID;
+                break;
 
-                default:
-                        goto err;
-                }
+            case POSIX_ACL_GROUP:
+            case POSIX_ACL_USER:
+            case POSIX_ACL_GROUP_OBJ:
+                ace->id = letoh32(entry->id);
+                break;
 
-                ace++;
-                entry++;
+            default:
+                goto err;
         }
 
-        posix_acl_normalize (this, acl);
+        ace++;
+        entry++;
+    }
+
+    posix_acl_normalize(this, acl);
 
-        return acl;
+    return acl;
 err:
-        posix_acl_destroy (this, acl);
-        return NULL;
+    posix_acl_destroy(this, acl);
+    return NULL;
 }
 
-
 int
-posix_acl_to_xattr (xlator_t *this, struct posix_acl *acl, char *xattr_buf,
-                    int xattr_size)
+posix_acl_to_xattr(xlator_t *this, struct posix_acl *acl, char *xattr_buf,
+                   int xattr_size)
 {
-        int                             size = 0;
-        struct posix_acl_xattr_header  *header = NULL;
-        struct posix_acl_xattr_entry   *entry = NULL;
-        struct posix_ace               *ace = NULL;
-        int                             i = 0;
-
-        size = sizeof (*header) + (acl->count * sizeof (*entry));
-
-        if (xattr_size < size)
-                return size;
-
-        header = (struct posix_acl_xattr_header *) (xattr_buf);
-        entry  = (struct posix_acl_xattr_entry *) (header + 1);
-        ace = acl->entries;
-
-        header->version = htole32 (POSIX_ACL_XATTR_VERSION);
-
-        for (i = 0; i < acl->count; i++) {
-                entry->tag   = htole16 (ace->tag);
-                entry->perm  = htole16 (ace->perm);
-
-                switch (ace->tag) {
-                case POSIX_ACL_USER:
-                case POSIX_ACL_GROUP:
-                        entry->id  = htole32 (ace->id);
-                        break;
-                default:
-                        entry->id = POSIX_ACL_UNDEFINED_ID;
-                        break;
-                }
-
-                ace++;
-                entry++;
+    int size = 0;
+    struct posix_acl_xattr_header *header = NULL;
+    struct posix_acl_xattr_entry *entry = NULL;
+    struct posix_ace *ace = NULL;
+    int i = 0;
+
+    size = sizeof(*header) + (acl->count * sizeof(*entry));
+
+    if (xattr_size < size)
+        return size;
+
+    header = (struct posix_acl_xattr_header *)(xattr_buf);
+    entry = (struct posix_acl_xattr_entry *)(header + 1);
+    ace = acl->entries;
+
+    header->version = htole32(POSIX_ACL_XATTR_VERSION);
+
+    for (i = 0; i < acl->count; i++) {
+        entry->tag = htole16(ace->tag);
+        entry->perm = htole16(ace->perm);
+
+        switch (ace->tag) {
+            case POSIX_ACL_USER:
+            case POSIX_ACL_GROUP:
+                entry->id = htole32(ace->id);
+                break;
+            default:
+                entry->id = POSIX_ACL_UNDEFINED_ID;
+                break;
         }
 
-        return 0;
-}
+        ace++;
+        entry++;
+    }
 
+    return 0;
+}
 
 int
-posix_acl_matches_xattr (xlator_t *this, struct posix_acl *acl, const char *buf,
-                         int size)
+posix_acl_matches_xattr(xlator_t *this, struct posix_acl *acl, const char *buf,
+                        int size)
 {
-        struct posix_acl  *acl2 = NULL;
-        int                ret = 1;
+    struct posix_acl *acl2 = NULL;
+    int ret = 1;
 
-        acl2 = posix_acl_from_xattr (this, buf, size);
-        if (!acl2)
-                return 0;
+    acl2 = posix_acl_from_xattr(this, buf, size);
+    if (!acl2)
+        return 0;
 
-        if (acl->count != acl2->count) {
-                ret = 0;
-                goto out;
-        }
+    if (acl->count != acl2->count) {
+        ret = 0;
+        goto out;
+    }
 
-        if (memcmp (acl->entries, acl2->entries,
-                    (acl->count * sizeof (struct posix_ace))))
-                ret = 0;
+    if (memcmp(acl->entries, acl2->entries,
+               (acl->count * sizeof(struct posix_ace))))
+        ret = 0;
 out:
-        posix_acl_destroy (this, acl2);
+    posix_acl_destroy(this, acl2);
 
-        return ret;
+    return ret;
 }
-
diff --git a/xlators/system/posix-acl/src/posix-acl.c b/xlators/system/posix-acl/src/posix-acl.c
index dd01d3e0f38..9183105ca00 100644
--- a/xlators/system/posix-acl/src/posix-acl.c
+++ b/xlators/system/posix-acl/src/posix-acl.c
@@ -21,2071 +21,1976 @@
 #define UINT64(ptr) ((uint64_t)((long)(ptr)))
 #define PTR(num) ((void *)((long)(num)))
 
-
 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_posix_acl_mt_end + 1);
-
-        if (ret != 0) {
-                gf_log(this->name, GF_LOG_ERROR, "Memory accounting init"
-                       "failed");
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_posix_acl_mt_end + 1);
 
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Memory accounting init"
+               "failed");
         return ret;
+    }
+
+    return ret;
 }
 
 static uid_t
-r00t ()
+r00t()
 {
-        struct posix_acl_conf *conf = NULL;
+    struct posix_acl_conf *conf = NULL;
 
-        conf = THIS->private;
+    conf = THIS->private;
 
-        return conf->super_uid;
+    return conf->super_uid;
 }
 
-
 int
-whitelisted_xattr (const char *key)
+whitelisted_xattr(const char *key)
 {
-        if (!key)
-                return 0;
-
-        if (strcmp (POSIX_ACL_ACCESS_XATTR, key) == 0)
-                return 1;
-        if (strcmp (POSIX_ACL_DEFAULT_XATTR, key) == 0)
-                return 1;
-        if (strcmp (GF_POSIX_ACL_ACCESS, key) == 0)
-                return 1;
-        if (strcmp (GF_POSIX_ACL_DEFAULT, key) == 0)
-                return 1;
+    if (!key)
         return 0;
-}
 
+    if (strcmp(POSIX_ACL_ACCESS_XATTR, key) == 0)
+        return 1;
+    if (strcmp(POSIX_ACL_DEFAULT_XATTR, key) == 0)
+        return 1;
+    if (strcmp(GF_POSIX_ACL_ACCESS, key) == 0)
+        return 1;
+    if (strcmp(GF_POSIX_ACL_DEFAULT, key) == 0)
+        return 1;
+    return 0;
+}
 
 int
-frame_is_user (call_frame_t *frame, uid_t uid)
+frame_is_user(call_frame_t *frame, uid_t uid)
 {
-        return (frame->root->uid == uid);
+    return (frame->root->uid == uid);
 }
 
-
 int
-frame_is_super_user (call_frame_t *frame)
+frame_is_super_user(call_frame_t *frame)
 {
-        int ret;
+    int ret;
 
-        ret = frame_is_user (frame, r00t());
-        if (!ret)
-                ret = frame_is_user (frame, 0);
+    ret = frame_is_user(frame, r00t());
+    if (!ret)
+        ret = frame_is_user(frame, 0);
 
-        return ret;
+    return ret;
 }
 
-
 int
-frame_in_group (call_frame_t *frame, gid_t gid)
+frame_in_group(call_frame_t *frame, gid_t gid)
 {
-        int  i = 0;
+    int i = 0;
 
-        if (frame->root->gid == gid)
-                return 1;
+    if (frame->root->gid == gid)
+        return 1;
 
-        for (i = 0; i < frame->root->ngrps; i++)
-                if (frame->root->groups[i] == gid)
-                        return 1;
-        return 0;
+    for (i = 0; i < frame->root->ngrps; i++)
+        if (frame->root->groups[i] == gid)
+            return 1;
+    return 0;
 }
 
-
 mode_t
-posix_acl_access_set_mode (struct posix_acl *acl, struct posix_acl_ctx *ctx)
-{
-        struct posix_ace  *ace = NULL;
-        struct posix_ace  *group_ce = NULL;
-        struct posix_ace  *mask_ce = NULL;
-        int                count = 0;
-        int                i = 0;
-        mode_t             mode = 0;
-        int                mask = 0;
-
-        count = acl->count;
-
-        ace = acl->entries;
-        for (i = 0; i < count; i++) {
-                switch (ace->tag) {
-                case POSIX_ACL_USER_OBJ:
-                        mask |= S_IRWXU;
-                        mode |= (ace->perm << 6);
-                        break;
-                case POSIX_ACL_GROUP_OBJ:
-                        group_ce = ace;
-                        break;
-                case POSIX_ACL_MASK:
-                        mask_ce = ace;
-                        break;
-                case POSIX_ACL_OTHER:
-                        mask |= S_IRWXO;
-                        mode |= (ace->perm);
-                        break;
-                }
-                ace++;
-        }
-
-        if (mask_ce) {
-                mask |= S_IRWXG;
-                mode |= (mask_ce->perm << 3);
-        } else {
-                if (!group_ce)
-                        goto out;
-                mask |= S_IRWXG;
-                mode |= (group_ce->perm << 3);
+posix_acl_access_set_mode(struct posix_acl *acl, struct posix_acl_ctx *ctx)
+{
+    struct posix_ace *ace = NULL;
+    struct posix_ace *group_ce = NULL;
+    struct posix_ace *mask_ce = NULL;
+    int count = 0;
+    int i = 0;
+    mode_t mode = 0;
+    int mask = 0;
+
+    count = acl->count;
+
+    ace = acl->entries;
+    for (i = 0; i < count; i++) {
+        switch (ace->tag) {
+            case POSIX_ACL_USER_OBJ:
+                mask |= S_IRWXU;
+                mode |= (ace->perm << 6);
+                break;
+            case POSIX_ACL_GROUP_OBJ:
+                group_ce = ace;
+                break;
+            case POSIX_ACL_MASK:
+                mask_ce = ace;
+                break;
+            case POSIX_ACL_OTHER:
+                mask |= S_IRWXO;
+                mode |= (ace->perm);
+                break;
         }
+        ace++;
+    }
+
+    if (mask_ce) {
+        mask |= S_IRWXG;
+        mode |= (mask_ce->perm << 3);
+    } else {
+        if (!group_ce)
+            goto out;
+        mask |= S_IRWXG;
+        mode |= (group_ce->perm << 3);
+    }
 
 out:
-        ctx->perm = (ctx->perm & ~mask) | mode;
+    ctx->perm = (ctx->perm & ~mask) | mode;
 
-        return mode;
+    return mode;
 }
 
-
 static int
-sticky_permits (call_frame_t *frame, inode_t *parent, inode_t *inode)
+sticky_permits(call_frame_t *frame, inode_t *parent, inode_t *inode)
 {
-        struct posix_acl_ctx  *par = NULL;
-        struct posix_acl_ctx  *ctx = NULL;
+    struct posix_acl_ctx *par = NULL;
+    struct posix_acl_ctx *ctx = NULL;
 
-        if ((0 > frame->root->pid) || frame_is_super_user (frame))
-                return 1;
+    if ((0 > frame->root->pid) || frame_is_super_user(frame))
+        return 1;
 
-        par = posix_acl_ctx_get (parent, frame->this);
-        if (par == NULL)
-                return 0;
+    par = posix_acl_ctx_get(parent, frame->this);
+    if (par == NULL)
+        return 0;
 
-        ctx = posix_acl_ctx_get (inode, frame->this);
-        if (ctx == NULL)
-                return 0;
+    ctx = posix_acl_ctx_get(inode, frame->this);
+    if (ctx == NULL)
+        return 0;
 
-        if (!(par->perm & S_ISVTX))
-                return 1;
+    if (!(par->perm & S_ISVTX))
+        return 1;
 
-        if (frame_is_user (frame, par->uid))
-                return 1;
+    if (frame_is_user(frame, par->uid))
+        return 1;
 
-        if (frame_is_user (frame, ctx->uid))
-                return 1;
+    if (frame_is_user(frame, ctx->uid))
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 static gf_boolean_t
-_does_acl_exist (struct posix_acl *acl)
+_does_acl_exist(struct posix_acl *acl)
 {
-        if (acl && (acl->count > POSIX_ACL_MINIMAL_ACE_COUNT))
-                return _gf_true;
-        return _gf_false;
+    if (acl && (acl->count > POSIX_ACL_MINIMAL_ACE_COUNT))
+        return _gf_true;
+    return _gf_false;
 }
 
 static void
-posix_acl_get_acl_string (call_frame_t *frame, struct posix_acl *acl,
-                          char **acl_str)
-{
-        int                   i        = 0;
-        size_t                size_acl = 0;
-        size_t                offset   = 0;
-        struct posix_ace      *ace     = NULL;
-        char                  tmp_str[1024] = {0};
-#define NON_GRP_FMT "(tag:%"PRIu16",perm:%"PRIu16",id:%"PRIu32")"
-#define GRP_FMT "(tag:%"PRIu16",perm:%"PRIu16",id:%"PRIu32",in-groups:%d)"
-
-        if (!_does_acl_exist (acl))
-                goto out;
-
-        ace = acl->entries;
-        for (i = 0; i < acl->count; i++) {
-                if (ace->tag != POSIX_ACL_GROUP) {
-                        size_acl += snprintf (tmp_str, sizeof tmp_str,
-                                     NON_GRP_FMT, ace->tag, ace->perm, ace->id);
-                } else {
-                        size_acl += snprintf (tmp_str, sizeof tmp_str,
-                                        GRP_FMT, ace->tag,
-                                       ace->perm, ace->id,
-                                       frame_in_group (frame, ace->id));
-                }
+posix_acl_get_acl_string(call_frame_t *frame, struct posix_acl *acl,
+                         char **acl_str)
+{
+    int i = 0;
+    size_t size_acl = 0;
+    size_t offset = 0;
+    struct posix_ace *ace = NULL;
+    char tmp_str[1024] = {0};
+#define NON_GRP_FMT "(tag:%" PRIu16 ",perm:%" PRIu16 ",id:%" PRIu32 ")"
+#define GRP_FMT "(tag:%" PRIu16 ",perm:%" PRIu16 ",id:%" PRIu32 ",in-groups:%d)"
+
+    if (!_does_acl_exist(acl))
+        goto out;
 
-                ace++;
+    ace = acl->entries;
+    for (i = 0; i < acl->count; i++) {
+        if (ace->tag != POSIX_ACL_GROUP) {
+            size_acl += snprintf(tmp_str, sizeof tmp_str, NON_GRP_FMT, ace->tag,
+                                 ace->perm, ace->id);
+        } else {
+            size_acl += snprintf(tmp_str, sizeof tmp_str, GRP_FMT, ace->tag,
+                                 ace->perm, ace->id,
+                                 frame_in_group(frame, ace->id));
         }
 
-        *acl_str = GF_CALLOC (1, size_acl + 1, gf_posix_acl_mt_char);
-        if (!*acl_str)
-                goto out;
+        ace++;
+    }
 
-        ace = acl->entries;
-        for (i = 0; i < acl->count; i++) {
-                if (ace->tag != POSIX_ACL_GROUP) {
-                        offset += snprintf (*acl_str + offset,
-                                            size_acl - offset,
-                                     NON_GRP_FMT, ace->tag, ace->perm, ace->id);
-                } else {
-                        offset += snprintf (*acl_str + offset,
-                                       size_acl - offset,
-                                       GRP_FMT, ace->tag, ace->perm, ace->id,
-                                       frame_in_group (frame, ace->id));
-                }
+    *acl_str = GF_CALLOC(1, size_acl + 1, gf_posix_acl_mt_char);
+    if (!*acl_str)
+        goto out;
 
-                ace++;
+    ace = acl->entries;
+    for (i = 0; i < acl->count; i++) {
+        if (ace->tag != POSIX_ACL_GROUP) {
+            offset += snprintf(*acl_str + offset, size_acl - offset,
+                               NON_GRP_FMT, ace->tag, ace->perm, ace->id);
+        } else {
+            offset += snprintf(*acl_str + offset, size_acl - offset, GRP_FMT,
+                               ace->tag, ace->perm, ace->id,
+                               frame_in_group(frame, ace->id));
         }
-out:
-        return;
-}
 
-static void
-posix_acl_log_permit_denied (call_frame_t *frame, inode_t *inode, int want,
-                             struct posix_acl_ctx *ctx, struct posix_acl *acl)
-{
-        char     *acl_str = NULL;
-        client_t *client  = NULL;
-
-        if (!frame || !inode || !ctx || !frame->root)
-                goto out;
-
-        client  = frame->root->client;
-        posix_acl_get_acl_string (frame, acl, &acl_str);
-
-        gf_msg (frame->this->name, GF_LOG_INFO, EACCES, POSIX_ACL_MSG_EACCES,
-                "client: %s, gfid: %s, req(uid:%d,gid:%d,perm:%d,"
-                "ngrps:%"PRIu16"), ctx(uid:%d,gid:%d,in-groups:%d,perm:%d%d%d,"
-                "updated-fop:%s, acl:%s)", client ? client->client_uid : "-",
-                uuid_utoa (inode->gfid), frame->root->uid, frame->root->gid,
-                want, frame->root->ngrps, ctx->uid, ctx->gid,
-                frame_in_group (frame, ctx->gid), (ctx->perm & S_IRWXU) >> 6,
-                (ctx->perm & S_IRWXG) >> 3, ctx->perm & S_IRWXO,
-                gf_fop_string (ctx->fop), acl_str ? acl_str : "-");
+        ace++;
+    }
 out:
-        GF_FREE (acl_str);
-        return;
+    return;
 }
 
-static int
-acl_permits (call_frame_t *frame, inode_t *inode, int want)
+static void
+posix_acl_log_permit_denied(call_frame_t *frame, inode_t *inode, int want,
+                            struct posix_acl_ctx *ctx, struct posix_acl *acl)
 {
-        int                     verdict = 0;
-        struct posix_acl       *acl = NULL;
-        struct posix_ace       *ace = NULL;
-        struct posix_acl_ctx   *ctx = NULL;
-        struct posix_acl_conf  *conf = NULL;
-        int                     i = 0;
-        int                     perm = 0;
-        int                     found = 0;
-        int                     acl_present = 0;
+    char *acl_str = NULL;
+    client_t *client = NULL;
 
-        conf = frame->this->private;
+    if (!frame || !inode || !ctx || !frame->root)
+        goto out;
 
-        if ((0 > frame->root->pid) || frame_is_super_user (frame))
-                goto green;
+    client = frame->root->client;
+    posix_acl_get_acl_string(frame, acl, &acl_str);
+
+    gf_msg(frame->this->name, GF_LOG_INFO, EACCES, POSIX_ACL_MSG_EACCES,
+           "client: %s, gfid: %s, req(uid:%d,gid:%d,perm:%d,"
+           "ngrps:%" PRIu16
+           "), ctx(uid:%d,gid:%d,in-groups:%d,perm:%d%d%d,"
+           "updated-fop:%s, acl:%s)",
+           client ? client->client_uid : "-", uuid_utoa(inode->gfid),
+           frame->root->uid, frame->root->gid, want, frame->root->ngrps,
+           ctx->uid, ctx->gid, frame_in_group(frame, ctx->gid),
+           (ctx->perm & S_IRWXU) >> 6, (ctx->perm & S_IRWXG) >> 3,
+           ctx->perm & S_IRWXO, gf_fop_string(ctx->fop),
+           acl_str ? acl_str : "-");
+out:
+    GF_FREE(acl_str);
+    return;
+}
 
-        ctx = posix_acl_ctx_get (inode, frame->this);
-        if (!ctx)
+static int
+acl_permits(call_frame_t *frame, inode_t *inode, int want)
+{
+    int verdict = 0;
+    struct posix_acl *acl = NULL;
+    struct posix_ace *ace = NULL;
+    struct posix_acl_ctx *ctx = NULL;
+    struct posix_acl_conf *conf = NULL;
+    int i = 0;
+    int perm = 0;
+    int found = 0;
+    int acl_present = 0;
+
+    conf = frame->this->private;
+
+    if ((0 > frame->root->pid) || frame_is_super_user(frame))
+        goto green;
+
+    ctx = posix_acl_ctx_get(inode, frame->this);
+    if (!ctx)
+        goto red;
+
+    posix_acl_get(inode, frame->this, &acl, NULL);
+    if (!acl) {
+        acl = posix_acl_ref(frame->this, conf->minimal_acl);
+    }
+
+    ace = acl->entries;
+
+    if (_does_acl_exist(acl))
+        acl_present = 1;
+
+    for (i = 0; i < acl->count; i++) {
+        switch (ace->tag) {
+            case POSIX_ACL_USER_OBJ:
+                perm = ((ctx->perm & S_IRWXU) >> 6);
+                if (frame_is_user(frame, ctx->uid))
+                    goto perm_check;
+                break;
+            case POSIX_ACL_USER:
+                perm = ace->perm;
+                if (frame_is_user(frame, ace->id))
+                    goto mask_check;
+                break;
+            case POSIX_ACL_GROUP_OBJ:
+                if (acl_present)
+                    perm = ace->perm;
+                else
+                    perm = ((ctx->perm & S_IRWXG) >> 3);
+                if (frame_in_group(frame, ctx->gid)) {
+                    found = 1;
+                    if ((perm & want) == want)
+                        goto mask_check;
+                }
+                break;
+            case POSIX_ACL_GROUP:
+                perm = ace->perm;
+                if (frame_in_group(frame, ace->id)) {
+                    found = 1;
+                    if ((perm & want) == want)
+                        goto mask_check;
+                }
+                break;
+            case POSIX_ACL_MASK:
+                break;
+            case POSIX_ACL_OTHER:
+                perm = (ctx->perm & S_IRWXO);
+                if (!found)
+                    goto perm_check;
+                /* fall through */
+            default:
                 goto red;
-
-        posix_acl_get (inode, frame->this, &acl, NULL);
-        if (!acl) {
-                acl = posix_acl_ref (frame->this, conf->minimal_acl);
         }
 
-        ace = acl->entries;
-
-        if (_does_acl_exist (acl))
-                acl_present = 1;
-
-        for (i = 0; i < acl->count; i++) {
-                switch (ace->tag) {
-                case POSIX_ACL_USER_OBJ:
-                        perm = ((ctx->perm & S_IRWXU) >> 6);
-                        if (frame_is_user (frame, ctx->uid))
-                                goto perm_check;
-                        break;
-                case POSIX_ACL_USER:
-                        perm = ace->perm;
-                        if (frame_is_user (frame, ace->id))
-                                goto mask_check;
-                        break;
-                case POSIX_ACL_GROUP_OBJ:
-                        if (acl_present)
-                                perm = ace->perm;
-                        else
-                                perm = ((ctx->perm & S_IRWXG) >> 3);
-                        if (frame_in_group (frame, ctx->gid)) {
-                                found = 1;
-                                if ((perm & want) == want)
-                                        goto mask_check;
-                        }
-                        break;
-                case POSIX_ACL_GROUP:
-                        perm = ace->perm;
-                        if (frame_in_group (frame, ace->id)) {
-                                found = 1;
-                                if ((perm & want) == want)
-                                        goto mask_check;
-                        }
-                        break;
-                case POSIX_ACL_MASK:
-                        break;
-                case POSIX_ACL_OTHER:
-                        perm = (ctx->perm & S_IRWXO);
-                        if (!found)
-                                goto perm_check;
-                        /* fall through */
-                default:
-                        goto red;
-                }
-
-                ace++;
-        }
+        ace++;
+    }
 
 mask_check:
-        ace = acl->entries;
+    ace = acl->entries;
 
-        for (i = 0; i < acl->count; i++, ace++) {
-                if (ace->tag != POSIX_ACL_MASK)
-                        continue;
-                if ((ace->perm & perm & want) == want) {
-                        goto green;
-                }
-                goto red;
+    for (i = 0; i < acl->count; i++, ace++) {
+        if (ace->tag != POSIX_ACL_MASK)
+            continue;
+        if ((ace->perm & perm & want) == want) {
+            goto green;
         }
+        goto red;
+    }
 
 perm_check:
-        if ((perm & want) == want) {
-                goto green;
-        } else {
-                goto red;
-        }
+    if ((perm & want) == want) {
+        goto green;
+    } else {
+        goto red;
+    }
 
 green:
-        verdict = 1;
-        goto out;
+    verdict = 1;
+    goto out;
 red:
-        verdict = 0;
-        posix_acl_log_permit_denied (frame, inode, want, ctx, acl);
+    verdict = 0;
+    posix_acl_log_permit_denied(frame, inode, want, ctx, acl);
 out:
-        if (acl)
-                posix_acl_unref (frame->this, acl);
+    if (acl)
+        posix_acl_unref(frame->this, acl);
 
-        return verdict;
+    return verdict;
 }
 
-
 struct posix_acl_ctx *
-__posix_acl_ctx_get (inode_t *inode, xlator_t *this, gf_boolean_t create)
+__posix_acl_ctx_get(inode_t *inode, xlator_t *this, gf_boolean_t create)
 {
-        struct posix_acl_ctx *ctx = NULL;
-        uint64_t              int_ctx = 0;
-        int                   ret = 0;
+    struct posix_acl_ctx *ctx = NULL;
+    uint64_t int_ctx = 0;
+    int ret = 0;
 
-        ret = __inode_ctx_get (inode, this, &int_ctx);
-        if ((ret == 0) && (int_ctx))
-                return PTR(int_ctx);
+    ret = __inode_ctx_get(inode, this, &int_ctx);
+    if ((ret == 0) && (int_ctx))
+        return PTR(int_ctx);
 
-        if (create == _gf_false)
-                return NULL;
+    if (create == _gf_false)
+        return NULL;
 
-        ctx = GF_CALLOC (1, sizeof (*ctx), gf_posix_acl_mt_ctx_t);
-        if (!ctx)
-                return NULL;
+    ctx = GF_CALLOC(1, sizeof(*ctx), gf_posix_acl_mt_ctx_t);
+    if (!ctx)
+        return NULL;
 
-        ret = __inode_ctx_put (inode, this, UINT64 (ctx));
-        if (ret) {
-                GF_FREE (ctx);
-                ctx = NULL;
-        }
+    ret = __inode_ctx_put(inode, this, UINT64(ctx));
+    if (ret) {
+        GF_FREE(ctx);
+        ctx = NULL;
+    }
 
-        return ctx;
+    return ctx;
 }
 
 struct posix_acl_ctx *
-posix_acl_ctx_new (inode_t *inode, xlator_t *this)
+posix_acl_ctx_new(inode_t *inode, xlator_t *this)
 {
-        struct posix_acl_ctx *ctx = NULL;
+    struct posix_acl_ctx *ctx = NULL;
 
-        if (inode == NULL) {
-                gf_log_callingfn (this->name, GF_LOG_WARNING, "inode is NULL");
-                return NULL;
-        }
+    if (inode == NULL) {
+        gf_log_callingfn(this->name, GF_LOG_WARNING, "inode is NULL");
+        return NULL;
+    }
 
-        LOCK (&inode->lock);
-        {
-                ctx = __posix_acl_ctx_get (inode, this, _gf_true);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ctx = __posix_acl_ctx_get(inode, this, _gf_true);
+    }
+    UNLOCK(&inode->lock);
 
-        if (ctx == NULL)
-                gf_log_callingfn (this->name, GF_LOG_ERROR, "creating inode ctx"
-                                  "failed for %s", uuid_utoa (inode->gfid));
-        return ctx;
+    if (ctx == NULL)
+        gf_log_callingfn(this->name, GF_LOG_ERROR,
+                         "creating inode ctx"
+                         "failed for %s",
+                         uuid_utoa(inode->gfid));
+    return ctx;
 }
 
 struct posix_acl_ctx *
-posix_acl_ctx_get (inode_t *inode, xlator_t *this)
+posix_acl_ctx_get(inode_t *inode, xlator_t *this)
 {
-        struct posix_acl_ctx *ctx = NULL;
+    struct posix_acl_ctx *ctx = NULL;
 
-        if (inode == NULL) {
-                gf_log_callingfn (this->name, GF_LOG_WARNING, "inode is NULL");
-                return NULL;
-        }
+    if (inode == NULL) {
+        gf_log_callingfn(this->name, GF_LOG_WARNING, "inode is NULL");
+        return NULL;
+    }
 
-        LOCK (&inode->lock);
-        {
-                ctx = __posix_acl_ctx_get (inode, this, _gf_false);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ctx = __posix_acl_ctx_get(inode, this, _gf_false);
+    }
+    UNLOCK(&inode->lock);
 
-        if (ctx == NULL)
-                gf_log_callingfn (this->name, GF_LOG_ERROR, "inode ctx is NULL "
-                                  "for %s", uuid_utoa (inode->gfid));
-        return ctx;
+    if (ctx == NULL)
+        gf_log_callingfn(this->name, GF_LOG_ERROR,
+                         "inode ctx is NULL "
+                         "for %s",
+                         uuid_utoa(inode->gfid));
+    return ctx;
 }
 
 int
-__posix_acl_set_specific (inode_t *inode, xlator_t *this,
-                          gf_boolean_t is_access, struct posix_acl *acl)
+__posix_acl_set_specific(inode_t *inode, xlator_t *this, gf_boolean_t is_access,
+                         struct posix_acl *acl)
 {
-        int                    ret = 0;
-        struct posix_acl_ctx  *ctx = NULL;
+    int ret = 0;
+    struct posix_acl_ctx *ctx = NULL;
 
-        ctx = posix_acl_ctx_get (inode, this);
-        if (!ctx) {
-                ret = -1;
-                goto out;
-        }
+    ctx = posix_acl_ctx_get(inode, this);
+    if (!ctx) {
+        ret = -1;
+        goto out;
+    }
 
-        if (is_access)
-                ctx->acl_access = acl;
-        else
-                ctx->acl_default = acl;
+    if (is_access)
+        ctx->acl_access = acl;
+    else
+        ctx->acl_default = acl;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__posix_acl_set (inode_t *inode, xlator_t *this, struct posix_acl *acl_access,
-                 struct posix_acl *acl_default)
+__posix_acl_set(inode_t *inode, xlator_t *this, struct posix_acl *acl_access,
+                struct posix_acl *acl_default)
 {
-        int                    ret = 0;
-        struct posix_acl_ctx  *ctx = NULL;
+    int ret = 0;
+    struct posix_acl_ctx *ctx = NULL;
 
-        ctx = posix_acl_ctx_get (inode, this);
-        if (!ctx)
-                goto out;
+    ctx = posix_acl_ctx_get(inode, this);
+    if (!ctx)
+        goto out;
 
-        ctx->acl_access = acl_access;
-        ctx->acl_default = acl_default;
+    ctx->acl_access = acl_access;
+    ctx->acl_default = acl_default;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-__posix_acl_get (inode_t *inode, xlator_t *this, struct posix_acl **acl_access_p,
-                 struct posix_acl **acl_default_p)
+__posix_acl_get(inode_t *inode, xlator_t *this, struct posix_acl **acl_access_p,
+                struct posix_acl **acl_default_p)
 {
-        int                    ret = 0;
-        struct posix_acl_ctx  *ctx = NULL;
+    int ret = 0;
+    struct posix_acl_ctx *ctx = NULL;
 
-        ctx = posix_acl_ctx_get (inode, this);
-        if (!ctx)
-                goto out;
+    ctx = posix_acl_ctx_get(inode, this);
+    if (!ctx)
+        goto out;
 
-        if (acl_access_p)
-                *acl_access_p = ctx->acl_access;
-        if (acl_default_p)
-                *acl_default_p = ctx->acl_default;
+    if (acl_access_p)
+        *acl_access_p = ctx->acl_access;
+    if (acl_default_p)
+        *acl_default_p = ctx->acl_default;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 struct posix_acl *
-posix_acl_new (xlator_t *this, int entrycnt)
+posix_acl_new(xlator_t *this, int entrycnt)
 {
-        struct posix_acl *acl = NULL;
-        struct posix_ace *ace = NULL;
+    struct posix_acl *acl = NULL;
+    struct posix_ace *ace = NULL;
 
-        acl = GF_CALLOC (1, sizeof (*acl) + (entrycnt * sizeof (*ace)),
-                         gf_posix_acl_mt_posix_ace_t);
-        if (!acl)
-                return NULL;
+    acl = GF_CALLOC(1, sizeof(*acl) + (entrycnt * sizeof(*ace)),
+                    gf_posix_acl_mt_posix_ace_t);
+    if (!acl)
+        return NULL;
 
-        acl->count = entrycnt;
+    acl->count = entrycnt;
 
-        posix_acl_ref (this, acl);
+    posix_acl_ref(this, acl);
 
-        return acl;
+    return acl;
 }
 
-
 void
-posix_acl_destroy (xlator_t *this, struct posix_acl *acl)
+posix_acl_destroy(xlator_t *this, struct posix_acl *acl)
 {
-       GF_FREE (acl);
+    GF_FREE(acl);
 
-        return;
+    return;
 }
 
-
 struct posix_acl *
-posix_acl_ref (xlator_t *this, struct posix_acl *acl)
+posix_acl_ref(xlator_t *this, struct posix_acl *acl)
 {
-        struct posix_acl_conf  *conf = NULL;
+    struct posix_acl_conf *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        LOCK(&conf->acl_lock);
-        {
-                acl->refcnt++;
-        }
-        UNLOCK(&conf->acl_lock);
+    LOCK(&conf->acl_lock);
+    {
+        acl->refcnt++;
+    }
+    UNLOCK(&conf->acl_lock);
 
-        return acl;
+    return acl;
 }
 
-
 struct posix_acl *
-posix_acl_dup (xlator_t *this, struct posix_acl *acl)
+posix_acl_dup(xlator_t *this, struct posix_acl *acl)
 {
-        struct posix_acl       *dup = NULL;
+    struct posix_acl *dup = NULL;
 
-        dup = posix_acl_new (this, acl->count);
-        if (!dup)
-                return NULL;
+    dup = posix_acl_new(this, acl->count);
+    if (!dup)
+        return NULL;
 
-        memcpy (dup->entries, acl->entries,
-                sizeof (struct posix_ace) * acl->count);
+    memcpy(dup->entries, acl->entries, sizeof(struct posix_ace) * acl->count);
 
-        return dup;
+    return dup;
 }
 
-
 void
-posix_acl_unref (xlator_t *this, struct posix_acl *acl)
+posix_acl_unref(xlator_t *this, struct posix_acl *acl)
 {
-        struct posix_acl_conf  *conf = NULL;
-        int                     refcnt = 0;
+    struct posix_acl_conf *conf = NULL;
+    int refcnt = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        LOCK(&conf->acl_lock);
-        {
-                refcnt = --acl->refcnt;
-        }
-        UNLOCK(&conf->acl_lock);
+    LOCK(&conf->acl_lock);
+    {
+        refcnt = --acl->refcnt;
+    }
+    UNLOCK(&conf->acl_lock);
 out:
-        if (!refcnt)
-                posix_acl_destroy (this, acl);
+    if (!refcnt)
+        posix_acl_destroy(this, acl);
 }
 
 int
-posix_acl_set_specific (inode_t *inode, xlator_t *this, struct posix_acl *acl,
-                        gf_boolean_t is_access)
+posix_acl_set_specific(inode_t *inode, xlator_t *this, struct posix_acl *acl,
+                       gf_boolean_t is_access)
 {
-        int                     ret = 0;
-        int                     oldret = 0;
-        struct posix_acl       *old_acl = NULL;
-        struct posix_acl_conf  *conf = NULL;
+    int ret = 0;
+    int oldret = 0;
+    struct posix_acl *old_acl = NULL;
+    struct posix_acl_conf *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        LOCK (&conf->acl_lock);
-        {
-                if (is_access)
-                        oldret = __posix_acl_get (inode, this, &old_acl, NULL);
-                else
-                        oldret = __posix_acl_get (inode, this, NULL, &old_acl);
-                if (acl)
-                        acl->refcnt++;
-                ret = __posix_acl_set_specific (inode, this, is_access, acl);
-        }
-        UNLOCK (&conf->acl_lock);
+    LOCK(&conf->acl_lock);
+    {
+        if (is_access)
+            oldret = __posix_acl_get(inode, this, &old_acl, NULL);
+        else
+            oldret = __posix_acl_get(inode, this, NULL, &old_acl);
+        if (acl)
+            acl->refcnt++;
+        ret = __posix_acl_set_specific(inode, this, is_access, acl);
+    }
+    UNLOCK(&conf->acl_lock);
 
-        if (oldret == 0) {
-                if (old_acl)
-                        posix_acl_unref (this, old_acl);
-        }
+    if (oldret == 0) {
+        if (old_acl)
+            posix_acl_unref(this, old_acl);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-posix_acl_set (inode_t *inode, xlator_t *this, struct posix_acl *acl_access,
-               struct posix_acl *acl_default)
+posix_acl_set(inode_t *inode, xlator_t *this, struct posix_acl *acl_access,
+              struct posix_acl *acl_default)
 {
-        int                     ret = 0;
-        int                     oldret = 0;
-        struct posix_acl       *old_access = NULL;
-        struct posix_acl       *old_default = NULL;
-        struct posix_acl_conf  *conf = NULL;
+    int ret = 0;
+    int oldret = 0;
+    struct posix_acl *old_access = NULL;
+    struct posix_acl *old_default = NULL;
+    struct posix_acl_conf *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        LOCK(&conf->acl_lock);
-        {
-                oldret = __posix_acl_get (inode, this, &old_access,
-                                          &old_default);
-                if (acl_access)
-                        acl_access->refcnt++;
-                if (acl_default)
-                        acl_default->refcnt++;
+    LOCK(&conf->acl_lock);
+    {
+        oldret = __posix_acl_get(inode, this, &old_access, &old_default);
+        if (acl_access)
+            acl_access->refcnt++;
+        if (acl_default)
+            acl_default->refcnt++;
 
-                ret = __posix_acl_set (inode, this, acl_access, acl_default);
-        }
-        UNLOCK(&conf->acl_lock);
+        ret = __posix_acl_set(inode, this, acl_access, acl_default);
+    }
+    UNLOCK(&conf->acl_lock);
 
-        if (oldret == 0) {
-                if (old_access)
-                        posix_acl_unref (this, old_access);
-                if (old_default)
-                        posix_acl_unref (this, old_default);
-        }
+    if (oldret == 0) {
+        if (old_access)
+            posix_acl_unref(this, old_access);
+        if (old_default)
+            posix_acl_unref(this, old_default);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-posix_acl_get (inode_t *inode, xlator_t *this, struct posix_acl **acl_access_p,
-               struct posix_acl **acl_default_p)
+posix_acl_get(inode_t *inode, xlator_t *this, struct posix_acl **acl_access_p,
+              struct posix_acl **acl_default_p)
 {
-        struct posix_acl_conf  *conf = NULL;
-        struct posix_acl       *acl_access = NULL;
-        struct posix_acl       *acl_default = NULL;
-        int                     ret = 0;
+    struct posix_acl_conf *conf = NULL;
+    struct posix_acl *acl_access = NULL;
+    struct posix_acl *acl_default = NULL;
+    int ret = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        LOCK(&conf->acl_lock);
-        {
-                ret = __posix_acl_get (inode, this, &acl_access, &acl_default);
+    LOCK(&conf->acl_lock);
+    {
+        ret = __posix_acl_get(inode, this, &acl_access, &acl_default);
 
-                if (ret != 0)
-                        goto unlock;
+        if (ret != 0)
+            goto unlock;
 
-                if (acl_access && acl_access_p)
-                        acl_access->refcnt++;
-                if (acl_default && acl_default_p)
-                        acl_default->refcnt++;
-        }
+        if (acl_access && acl_access_p)
+            acl_access->refcnt++;
+        if (acl_default && acl_default_p)
+            acl_default->refcnt++;
+    }
 unlock:
-        UNLOCK(&conf->acl_lock);
+    UNLOCK(&conf->acl_lock);
 
-        if (acl_access_p)
-                *acl_access_p = acl_access;
-        if (acl_default_p)
-                *acl_default_p = acl_default;
+    if (acl_access_p)
+        *acl_access_p = acl_access;
+    if (acl_default_p)
+        *acl_default_p = acl_default;
 
-        return ret;
+    return ret;
 }
 
 mode_t
-posix_acl_inherit_mode (struct posix_acl *acl, mode_t modein)
-{
-        struct posix_ace       *ace = NULL;
-        int                     count = 0;
-        int                     i = 0;
-        mode_t                  newmode = 0;
-        mode_t                  mode = 0;
-        struct posix_ace       *mask_ce = NULL;
-        struct posix_ace       *group_ce = NULL;
-
-        newmode = mode = modein;
-
-        count = acl->count;
-
-        ace = acl->entries;
-        for (i = 0; i < count; i++) {
-                switch (ace->tag) {
-                case POSIX_ACL_USER_OBJ:
-                        ace->perm &= (mode >> 6) | ~S_IRWXO;
-                        mode &= (ace->perm << 6) | ~S_IRWXU;
-                        break;
-                case POSIX_ACL_GROUP_OBJ:
-                        group_ce = ace;
-                        break;
-                case POSIX_ACL_MASK:
-                        mask_ce = ace;
-                        break;
-                case POSIX_ACL_OTHER:
-                        ace->perm &= (mode) | ~S_IRWXO;
-                        mode &= (ace->perm) | ~S_IRWXO;
-                        break;
-                }
-                ace++;
+posix_acl_inherit_mode(struct posix_acl *acl, mode_t modein)
+{
+    struct posix_ace *ace = NULL;
+    int count = 0;
+    int i = 0;
+    mode_t newmode = 0;
+    mode_t mode = 0;
+    struct posix_ace *mask_ce = NULL;
+    struct posix_ace *group_ce = NULL;
+
+    newmode = mode = modein;
+
+    count = acl->count;
+
+    ace = acl->entries;
+    for (i = 0; i < count; i++) {
+        switch (ace->tag) {
+            case POSIX_ACL_USER_OBJ:
+                ace->perm &= (mode >> 6) | ~S_IRWXO;
+                mode &= (ace->perm << 6) | ~S_IRWXU;
+                break;
+            case POSIX_ACL_GROUP_OBJ:
+                group_ce = ace;
+                break;
+            case POSIX_ACL_MASK:
+                mask_ce = ace;
+                break;
+            case POSIX_ACL_OTHER:
+                ace->perm &= (mode) | ~S_IRWXO;
+                mode &= (ace->perm) | ~S_IRWXO;
+                break;
         }
+        ace++;
+    }
 
-        if (mask_ce) {
-                mask_ce->perm &= (mode >> 3) | ~S_IRWXO;
-                mode &= (mask_ce->perm << 3) | ~S_IRWXG;
-        } else if (group_ce) {
-                group_ce->perm &= (mode >> 3) | ~S_IRWXO;
-                mode &= (group_ce->perm << 3) | ~S_IRWXG;
-        }
+    if (mask_ce) {
+        mask_ce->perm &= (mode >> 3) | ~S_IRWXO;
+        mode &= (mask_ce->perm << 3) | ~S_IRWXG;
+    } else if (group_ce) {
+        group_ce->perm &= (mode >> 3) | ~S_IRWXO;
+        mode &= (group_ce->perm << 3) | ~S_IRWXG;
+    }
 
-        newmode = ((modein & (S_IFMT | S_ISUID | S_ISGID | S_ISVTX)) |
-		   (mode & (S_IRWXU|S_IRWXG|S_IRWXO)));
+    newmode = ((modein & (S_IFMT | S_ISUID | S_ISGID | S_ISVTX)) |
+               (mode & (S_IRWXU | S_IRWXG | S_IRWXO)));
 
-        return newmode;
+    return newmode;
 }
 
-
 mode_t
-posix_acl_inherit (xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
-                   int32_t umask, int is_dir)
-{
-        int                    ret = 0;
-        struct posix_acl      *par_default = NULL;
-        struct posix_acl      *acl_default = NULL;
-        struct posix_acl      *acl_access = NULL;
-        struct posix_acl_ctx  *ctx = NULL;
-        char                  *xattr_default = NULL;
-        char                  *xattr_access = NULL;
-        int                    size_default = 0;
-        int                    size_access = 0;
-        mode_t                 retmode = 0;
-        int16_t                tmp_mode = 0;
-        mode_t                 client_umask = 0;
-
-        retmode = mode;
-        client_umask = umask;
-        ret = dict_get_int16 (params, "umask", &tmp_mode);
+posix_acl_inherit(xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
+                  int32_t umask, int is_dir)
+{
+    int ret = 0;
+    struct posix_acl *par_default = NULL;
+    struct posix_acl *acl_default = NULL;
+    struct posix_acl *acl_access = NULL;
+    struct posix_acl_ctx *ctx = NULL;
+    char *xattr_default = NULL;
+    char *xattr_access = NULL;
+    int size_default = 0;
+    int size_access = 0;
+    mode_t retmode = 0;
+    int16_t tmp_mode = 0;
+    mode_t client_umask = 0;
+
+    retmode = mode;
+    client_umask = umask;
+    ret = dict_get_int16(params, "umask", &tmp_mode);
+    if (ret == 0) {
+        client_umask = (mode_t)tmp_mode;
+        dict_del(params, "umask");
+        ret = dict_get_int16(params, "mode", &tmp_mode);
         if (ret == 0) {
-                client_umask = (mode_t)tmp_mode;
-                dict_del (params, "umask");
-                ret = dict_get_int16 (params, "mode", &tmp_mode);
-                if (ret == 0) {
-                        retmode = (mode_t)tmp_mode;
-                        dict_del (params, "mode");
-                } else {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "client sent umask, but not the original mode");
-                }
+            retmode = (mode_t)tmp_mode;
+            dict_del(params, "mode");
+        } else {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "client sent umask, but not the original mode");
         }
+    }
 
-        ret = posix_acl_get (loc->parent, this, NULL, &par_default);
+    ret = posix_acl_get(loc->parent, this, NULL, &par_default);
 
-        if (!par_default)
-                goto out;
-
-        ctx = posix_acl_ctx_new (loc->inode, this);
+    if (!par_default)
+        goto out;
 
-        acl_access = posix_acl_dup (this, par_default);
-        if (!acl_access)
-                goto out;
+    ctx = posix_acl_ctx_new(loc->inode, this);
 
-        client_umask = 0; // No umask if we inherit an ACL
-        retmode = posix_acl_inherit_mode (acl_access, retmode);
-        ctx->perm = retmode;
+    acl_access = posix_acl_dup(this, par_default);
+    if (!acl_access)
+        goto out;
 
-        size_access = posix_acl_to_xattr (this, acl_access, NULL, 0);
-        xattr_access = GF_CALLOC (1, size_access, gf_posix_acl_mt_char);
-        if (!xattr_access) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                ret = -1;
-                goto out;
-        }
-        posix_acl_to_xattr (this, acl_access, xattr_access, size_access);
-
-        ret = dict_set_bin (params, POSIX_ACL_ACCESS_XATTR, xattr_access,
-                            size_access);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                GF_FREE (xattr_access);
-                ret = -1;
-                goto out;
-        }
+    client_umask = 0;  // No umask if we inherit an ACL
+    retmode = posix_acl_inherit_mode(acl_access, retmode);
+    ctx->perm = retmode;
 
-        if (!is_dir)
-                goto set;
+    size_access = posix_acl_to_xattr(this, acl_access, NULL, 0);
+    xattr_access = GF_CALLOC(1, size_access, gf_posix_acl_mt_char);
+    if (!xattr_access) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        ret = -1;
+        goto out;
+    }
+    posix_acl_to_xattr(this, acl_access, xattr_access, size_access);
+
+    ret = dict_set_bin(params, POSIX_ACL_ACCESS_XATTR, xattr_access,
+                       size_access);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        GF_FREE(xattr_access);
+        ret = -1;
+        goto out;
+    }
 
+    if (!is_dir)
+        goto set;
 
-        acl_default = posix_acl_ref (this, par_default);
+    acl_default = posix_acl_ref(this, par_default);
 
-        size_default = posix_acl_to_xattr (this, acl_default, NULL, 0);
-        xattr_default = GF_CALLOC (1, size_default, gf_posix_acl_mt_char);
-        if (!xattr_default) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                ret = -1;
-                goto out;
-        }
-        posix_acl_to_xattr (this, acl_default, xattr_default, size_default);
-
-        ret = dict_set_bin (params, POSIX_ACL_DEFAULT_XATTR, xattr_default,
-                            size_default);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "out of memory");
-                GF_FREE (xattr_default);
-                ret = -1;
-                goto out;
-        }
+    size_default = posix_acl_to_xattr(this, acl_default, NULL, 0);
+    xattr_default = GF_CALLOC(1, size_default, gf_posix_acl_mt_char);
+    if (!xattr_default) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        ret = -1;
+        goto out;
+    }
+    posix_acl_to_xattr(this, acl_default, xattr_default, size_default);
+
+    ret = dict_set_bin(params, POSIX_ACL_DEFAULT_XATTR, xattr_default,
+                       size_default);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        GF_FREE(xattr_default);
+        ret = -1;
+        goto out;
+    }
 
 set:
-        ret = posix_acl_set (loc->inode, this, acl_access, acl_default);
-        if (ret != 0)
-                goto out;
+    ret = posix_acl_set(loc->inode, this, acl_access, acl_default);
+    if (ret != 0)
+        goto out;
 
 out:
-        retmode &= ~client_umask;
+    retmode &= ~client_umask;
 
-        if (par_default)
-                posix_acl_unref (this, par_default);
-        if (acl_access)
-                posix_acl_unref (this, acl_access);
-        if (acl_default)
-                posix_acl_unref (this, acl_default);
+    if (par_default)
+        posix_acl_unref(this, par_default);
+    if (acl_access)
+        posix_acl_unref(this, acl_access);
+    if (acl_default)
+        posix_acl_unref(this, acl_default);
 
-        return retmode;
+    return retmode;
 }
 
-
 mode_t
-posix_acl_inherit_dir (xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
-                       int32_t umask)
+posix_acl_inherit_dir(xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
+                      int32_t umask)
 {
-        mode_t  retmode = 0;
+    mode_t retmode = 0;
 
-        retmode = posix_acl_inherit (this, loc, params, mode, umask, 1);
+    retmode = posix_acl_inherit(this, loc, params, mode, umask, 1);
 
-        return retmode;
+    return retmode;
 }
 
-
 mode_t
-posix_acl_inherit_file (xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
-                        int32_t umask)
+posix_acl_inherit_file(xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
+                       int32_t umask)
 {
-        mode_t  retmode = 0;
+    mode_t retmode = 0;
 
-        retmode = posix_acl_inherit (this, loc, params, mode, umask, 0);
+    retmode = posix_acl_inherit(this, loc, params, mode, umask, 0);
 
-        return retmode;
+    return retmode;
 }
 
 int
-posix_acl_ctx_update (inode_t *inode, xlator_t *this, struct iatt *buf,
-                      glusterfs_fop_t fop)
+posix_acl_ctx_update(inode_t *inode, xlator_t *this, struct iatt *buf,
+                     glusterfs_fop_t fop)
 {
-        struct posix_acl_ctx *ctx = NULL;
-	struct posix_acl     *acl = NULL;
-	struct posix_ace     *ace = NULL;
-	struct posix_ace     *mask_ce = NULL;
-	struct posix_ace     *group_ce = NULL;
-        int                   ret = 0;
-	int                   i = 0;
-
-        LOCK(&inode->lock);
-        {
-                ctx = __posix_acl_ctx_get (inode, this, _gf_true);
-                if (!ctx) {
-                        ret = -1;
-                        goto unlock;
-                }
+    struct posix_acl_ctx *ctx = NULL;
+    struct posix_acl *acl = NULL;
+    struct posix_ace *ace = NULL;
+    struct posix_ace *mask_ce = NULL;
+    struct posix_ace *group_ce = NULL;
+    int ret = 0;
+    int i = 0;
 
-                ctx->uid   = buf->ia_uid;
-                ctx->gid   = buf->ia_gid;
-                ctx->perm  = st_mode_from_ia (buf->ia_prot, buf->ia_type);
-                ctx->fop   = fop;
-
-		acl = ctx->acl_access;
-                if (!_does_acl_exist (acl))
-			goto unlock;
-
-		/* This is an extended ACL (not minimal acl). In case we
-		   are only refreshing from iatt and not ACL xattrs (for
-		   e.g. from postattributes of setattr() call, we need to
-		   update the corresponding ACEs as well.
-		*/
-		ace = acl->entries;
-		for (i = 0; i < acl->count; i++) {
-			switch (ace->tag) {
-			case POSIX_ACL_USER_OBJ:
-				ace->perm = (ctx->perm & S_IRWXU) >> 6;
-				break;
-			case POSIX_ACL_USER:
-			case POSIX_ACL_GROUP:
-				break;
-			case POSIX_ACL_GROUP_OBJ:
-				group_ce = ace;
-				break;
-			case POSIX_ACL_MASK:
-				mask_ce = ace;
-				break;
-			case POSIX_ACL_OTHER:
-				ace->perm = (ctx->perm & S_IRWXO);
-				break;
-			}
-			ace++;
-		}
-
-		if (mask_ce)
-			mask_ce->perm = (ctx->perm & S_IRWXG) >> 3;
-		else if (group_ce)
-			group_ce->perm = (ctx->perm & S_IRWXG) >> 3;
-		else
-			ret = -1;
+    LOCK(&inode->lock);
+    {
+        ctx = __posix_acl_ctx_get(inode, this, _gf_true);
+        if (!ctx) {
+            ret = -1;
+            goto unlock;
         }
-unlock:
-        UNLOCK(&inode->lock);
-        return ret;
-}
 
-int
-posix_acl_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)
-{
-        struct posix_acl     *acl_access  = NULL;
-        struct posix_acl     *acl_default = NULL;
-        struct posix_acl     *old_access  = NULL;
-        struct posix_acl     *old_default = NULL;
-        struct posix_acl_ctx *ctx         = NULL;
-        data_t               *data        = NULL;
-        int                   ret         = 0;
-        dict_t               *my_xattr    = NULL;
+        ctx->uid = buf->ia_uid;
+        ctx->gid = buf->ia_gid;
+        ctx->perm = st_mode_from_ia(buf->ia_prot, buf->ia_type);
+        ctx->fop = fop;
 
-        if (op_ret != 0)
-                goto unwind;
+        acl = ctx->acl_access;
+        if (!_does_acl_exist(acl))
+            goto unlock;
 
-        ctx = posix_acl_ctx_new (inode, this);
-        if (!ctx) {
-                op_ret = -1;
-                op_errno = ENOMEM;
-                goto unwind;
+        /* This is an extended ACL (not minimal acl). In case we
+           are only refreshing from iatt and not ACL xattrs (for
+           e.g. from postattributes of setattr() call, we need to
+           update the corresponding ACEs as well.
+        */
+        ace = acl->entries;
+        for (i = 0; i < acl->count; i++) {
+            switch (ace->tag) {
+                case POSIX_ACL_USER_OBJ:
+                    ace->perm = (ctx->perm & S_IRWXU) >> 6;
+                    break;
+                case POSIX_ACL_USER:
+                case POSIX_ACL_GROUP:
+                    break;
+                case POSIX_ACL_GROUP_OBJ:
+                    group_ce = ace;
+                    break;
+                case POSIX_ACL_MASK:
+                    mask_ce = ace;
+                    break;
+                case POSIX_ACL_OTHER:
+                    ace->perm = (ctx->perm & S_IRWXO);
+                    break;
+            }
+            ace++;
         }
 
-        ret = posix_acl_get (inode, this, &old_access, &old_default);
-
-        if (xattr == NULL)
-                goto acl_set;
-
-        data = dict_get (xattr, POSIX_ACL_ACCESS_XATTR);
-        if (!data)
-                goto acl_default;
+        if (mask_ce)
+            mask_ce->perm = (ctx->perm & S_IRWXG) >> 3;
+        else if (group_ce)
+            group_ce->perm = (ctx->perm & S_IRWXG) >> 3;
+        else
+            ret = -1;
+    }
+unlock:
+    UNLOCK(&inode->lock);
+    return ret;
+}
 
-        if (old_access &&
-            posix_acl_matches_xattr (this, old_access, data->data,
-                                     data->len)) {
-                acl_access = posix_acl_ref (this, old_access);
-        } else {
-                acl_access = posix_acl_from_xattr (this, data->data,
-                                                   data->len);
-        }
+int
+posix_acl_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)
+{
+    struct posix_acl *acl_access = NULL;
+    struct posix_acl *acl_default = NULL;
+    struct posix_acl *old_access = NULL;
+    struct posix_acl *old_default = NULL;
+    struct posix_acl_ctx *ctx = NULL;
+    data_t *data = NULL;
+    int ret = 0;
+    dict_t *my_xattr = NULL;
+
+    if (op_ret != 0)
+        goto unwind;
+
+    ctx = posix_acl_ctx_new(inode, this);
+    if (!ctx) {
+        op_ret = -1;
+        op_errno = ENOMEM;
+        goto unwind;
+    }
+
+    ret = posix_acl_get(inode, this, &old_access, &old_default);
+
+    if (xattr == NULL)
+        goto acl_set;
+
+    data = dict_get(xattr, POSIX_ACL_ACCESS_XATTR);
+    if (!data)
+        goto acl_default;
+
+    if (old_access &&
+        posix_acl_matches_xattr(this, old_access, data->data, data->len)) {
+        acl_access = posix_acl_ref(this, old_access);
+    } else {
+        acl_access = posix_acl_from_xattr(this, data->data, data->len);
+    }
 
 acl_default:
-        data = dict_get (xattr, POSIX_ACL_DEFAULT_XATTR);
-        if (!data)
-                goto acl_set;
+    data = dict_get(xattr, POSIX_ACL_DEFAULT_XATTR);
+    if (!data)
+        goto acl_set;
 
-        if (old_default &&
-            posix_acl_matches_xattr (this, old_default, data->data,
-                                     data->len)) {
-                acl_default = posix_acl_ref (this, old_default);
-        } else {
-                acl_default = posix_acl_from_xattr (this, data->data,
-                                                    data->len);
-        }
+    if (old_default &&
+        posix_acl_matches_xattr(this, old_default, data->data, data->len)) {
+        acl_default = posix_acl_ref(this, old_default);
+    } else {
+        acl_default = posix_acl_from_xattr(this, data->data, data->len);
+    }
 
 acl_set:
-        posix_acl_ctx_update (inode, this, buf, GF_FOP_LOOKUP);
+    posix_acl_ctx_update(inode, this, buf, GF_FOP_LOOKUP);
 
-        ret = posix_acl_set (inode, this, acl_access, acl_default);
-        if (ret)
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set ACL in context");
+    ret = posix_acl_set(inode, this, acl_access, acl_default);
+    if (ret)
+        gf_log(this->name, GF_LOG_WARNING, "failed to set ACL in context");
 unwind:
-        my_xattr = frame->local;
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xattr,
-                             postparent);
+    my_xattr = frame->local;
+    frame->local = NULL;
+    STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xattr,
+                        postparent);
 
-        if (acl_access)
-                posix_acl_unref (this, acl_access);
-        if (acl_default)
-                posix_acl_unref (this, acl_default);
-        if (old_access)
-                posix_acl_unref (this, old_access);
-        if (old_default)
-                posix_acl_unref (this, old_default);
-        if (my_xattr)
-                dict_unref (my_xattr);
+    if (acl_access)
+        posix_acl_unref(this, acl_access);
+    if (acl_default)
+        posix_acl_unref(this, acl_default);
+    if (old_access)
+        posix_acl_unref(this, old_access);
+    if (old_default)
+        posix_acl_unref(this, old_default);
+    if (my_xattr)
+        dict_unref(my_xattr);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  dict_t *xattr)
+posix_acl_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr)
 {
-        int      ret = 0;
-        dict_t  *my_xattr = NULL;
+    int ret = 0;
+    dict_t *my_xattr = NULL;
 
-        if (!loc->parent)
-                /* lookup of / is always permitted */
-                goto green;
+    if (!loc->parent)
+        /* lookup of / is always permitted */
+        goto green;
 
-        if (acl_permits (frame, loc->parent, POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 
 green:
-        if (xattr) {
-                my_xattr = dict_ref (xattr);
-        } else {
-                my_xattr = dict_new ();
-        }
-
-        ret = dict_set_int8 (my_xattr, POSIX_ACL_ACCESS_XATTR, 0);
-        if (ret)
-                gf_log (this->name, GF_LOG_WARNING, "failed to set key %s",
-                        POSIX_ACL_ACCESS_XATTR);
-
-        ret = dict_set_int8 (my_xattr, POSIX_ACL_DEFAULT_XATTR, 0);
-        if (ret)
-                gf_log (this->name, GF_LOG_WARNING, "failed to set key %s",
-                        POSIX_ACL_DEFAULT_XATTR);
-
-        frame->local = my_xattr;
-        STACK_WIND (frame, posix_acl_lookup_cbk,
-                    FIRST_CHILD (this), FIRST_CHILD (this)->fops->lookup,
-                    loc, my_xattr);
-        return 0;
+    if (xattr) {
+        my_xattr = dict_ref(xattr);
+    } else {
+        my_xattr = dict_new();
+    }
+
+    ret = dict_set_int8(my_xattr, POSIX_ACL_ACCESS_XATTR, 0);
+    if (ret)
+        gf_log(this->name, GF_LOG_WARNING, "failed to set key %s",
+               POSIX_ACL_ACCESS_XATTR);
+
+    ret = dict_set_int8(my_xattr, POSIX_ACL_DEFAULT_XATTR, 0);
+    if (ret)
+        gf_log(this->name, GF_LOG_WARNING, "failed to set key %s",
+               POSIX_ACL_DEFAULT_XATTR);
+
+    frame->local = my_xattr;
+    STACK_WIND(frame, posix_acl_lookup_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->lookup, loc, my_xattr);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (lookup, frame, -1, EACCES, NULL, NULL, NULL,
-                             NULL);
-
-        return 0;
-}
-
-
-int
-posix_acl_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int mask,
-                  dict_t *xdata)
-{
-        int  op_ret = 0;
-        int  op_errno = 0;
-        int  perm = 0;
-        int  mode = 0;
-        int  is_fuse_call = 0;
-
-        is_fuse_call = __is_fuse_call (frame);
-
-        if (mask & R_OK)
-                perm |= POSIX_ACL_READ;
-        if (mask & W_OK)
-                perm |= POSIX_ACL_WRITE;
-        if (mask & X_OK)
-                perm |= POSIX_ACL_EXECUTE;
-        if (!mask) {
-                goto unwind;
+    STACK_UNWIND_STRICT(lookup, frame, -1, EACCES, NULL, NULL, NULL, NULL);
+
+    return 0;
+}
+
+int
+posix_acl_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int mask,
+                 dict_t *xdata)
+{
+    int op_ret = 0;
+    int op_errno = 0;
+    int perm = 0;
+    int mode = 0;
+    int is_fuse_call = 0;
+
+    is_fuse_call = __is_fuse_call(frame);
+
+    if (mask & R_OK)
+        perm |= POSIX_ACL_READ;
+    if (mask & W_OK)
+        perm |= POSIX_ACL_WRITE;
+    if (mask & X_OK)
+        perm |= POSIX_ACL_EXECUTE;
+    if (!mask) {
+        goto unwind;
+    }
+    if (!perm) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto unwind;
+    }
+
+    if (is_fuse_call) {
+        mode = acl_permits(frame, loc->inode, perm);
+        if (mode) {
+            op_ret = 0;
+            op_errno = 0;
+        } else {
+            op_ret = -1;
+            op_errno = EACCES;
         }
-        if (!perm) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto unwind;
+    } else {
+        if (perm & POSIX_ACL_READ) {
+            if (acl_permits(frame, loc->inode, POSIX_ACL_READ))
+                mode |= POSIX_ACL_READ;
         }
 
-        if (is_fuse_call) {
-                mode = acl_permits (frame, loc->inode, perm);
-                if (mode) {
-                        op_ret = 0;
-                        op_errno = 0;
-                } else {
-                        op_ret = -1;
-                        op_errno = EACCES;
-                }
-        } else {
-                if (perm & POSIX_ACL_READ) {
-                        if (acl_permits (frame, loc->inode, POSIX_ACL_READ))
-                                mode |= POSIX_ACL_READ;
-                }
-
-                if (perm & POSIX_ACL_WRITE) {
-                        if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE))
-                                mode |= POSIX_ACL_WRITE;
-                }
+        if (perm & POSIX_ACL_WRITE) {
+            if (acl_permits(frame, loc->inode, POSIX_ACL_WRITE))
+                mode |= POSIX_ACL_WRITE;
+        }
 
-                if (perm & POSIX_ACL_EXECUTE) {
-                        if (acl_permits (frame, loc->inode, POSIX_ACL_EXECUTE))
-                                mode |= POSIX_ACL_EXECUTE;
-                }
+        if (perm & POSIX_ACL_EXECUTE) {
+            if (acl_permits(frame, loc->inode, POSIX_ACL_EXECUTE))
+                mode |= POSIX_ACL_EXECUTE;
         }
+    }
 
 unwind:
-        if (is_fuse_call)
-                STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, NULL);
-        else
-                STACK_UNWIND_STRICT (access, frame, 0, mode, NULL);
-        return 0;
+    if (is_fuse_call)
+        STACK_UNWIND_STRICT(access, frame, op_ret, op_errno, NULL);
+    else
+        STACK_UNWIND_STRICT(access, frame, 0, mode, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+posix_acl_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf,
-                             postbuf, xdata);
+    STACK_UNWIND_STRICT(truncate, frame, op_ret, op_errno, prebuf, postbuf,
+                        xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t off,
-                    dict_t *xdata)
+posix_acl_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t off,
+                   dict_t *xdata)
 {
-        struct posix_acl_ctx *ctx = NULL;
+    struct posix_acl_ctx *ctx = NULL;
 
-        if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE))
-                goto green;
-        /* NFS does a truncate through SETATTR, the owner does not need write
-         * permissions for this. Group permissions and root are checked above.
-         */
-        else if (frame->root->pid == NFS_PID) {
-                ctx = posix_acl_ctx_get (loc->inode, frame->this);
+    if (acl_permits(frame, loc->inode, POSIX_ACL_WRITE))
+        goto green;
+    /* NFS does a truncate through SETATTR, the owner does not need write
+     * permissions for this. Group permissions and root are checked above.
+     */
+    else if (frame->root->pid == NFS_PID) {
+        ctx = posix_acl_ctx_get(loc->inode, frame->this);
 
-                if (ctx && frame_is_user (frame, ctx->uid))
-                        goto green;
-        }
+        if (ctx && frame_is_user(frame, ctx->uid))
+            goto green;
+    }
 
-        /* fail by default */
-        STACK_UNWIND_STRICT (truncate, frame, -1, EACCES, NULL, NULL, NULL);
-        return 0;
+    /* fail by default */
+    STACK_UNWIND_STRICT(truncate, frame, -1, EACCES, NULL, NULL, NULL);
+    return 0;
 
 green:
-        STACK_WIND (frame, posix_acl_truncate_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate,
-                    loc, off, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_truncate_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->truncate, loc, off, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+posix_acl_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata);
+    STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-                fd_t *fd, dict_t *xdata)
+posix_acl_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+               fd_t *fd, dict_t *xdata)
 {
-        int perm = 0;
+    int perm = 0;
 
-        switch (flags & O_ACCMODE) {
+    switch (flags & O_ACCMODE) {
         case O_RDONLY:
-                perm = POSIX_ACL_READ;
+            perm = POSIX_ACL_READ;
 
-                /* If O_FMODE_EXEC is present, its good enough
-                   to have '--x' perm, and its not covered in
-                   O_ACCMODE bits */
-                if (flags & O_FMODE_EXEC)
-                        perm = POSIX_ACL_EXECUTE;
+            /* If O_FMODE_EXEC is present, its good enough
+               to have '--x' perm, and its not covered in
+               O_ACCMODE bits */
+            if (flags & O_FMODE_EXEC)
+                perm = POSIX_ACL_EXECUTE;
 
-                break;
+            break;
         case O_WRONLY:
-                perm = POSIX_ACL_WRITE;
-                break;
+            perm = POSIX_ACL_WRITE;
+            break;
         case O_RDWR:
-                perm = POSIX_ACL_READ|POSIX_ACL_WRITE;
-                break;
-        }
+            perm = POSIX_ACL_READ | POSIX_ACL_WRITE;
+            break;
+    }
 
-        if (flags & (O_TRUNC | O_APPEND))
-                perm |= POSIX_ACL_WRITE;
+    if (flags & (O_TRUNC | O_APPEND))
+        perm |= POSIX_ACL_WRITE;
 
-        if (acl_permits (frame, loc->inode, perm))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->inode, perm))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_open_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->open,
-                    loc, flags, fd, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_open_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (open, frame, -1, EACCES, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(open, frame, -1, EACCES, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, struct iovec *vector,
-                     int count, struct iatt *stbuf, struct iobref *iobref,
-                     dict_t *xdata)
+posix_acl_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, struct iovec *vector, int count,
+                    struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count,
-                             stbuf, iobref, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf,
+                        iobref, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 size_t size, off_t offset, uint32_t flags, dict_t *xdata)
+posix_acl_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                off_t offset, uint32_t flags, dict_t *xdata)
 {
-        if (__is_fuse_call (frame))
-                goto green;
+    if (__is_fuse_call(frame))
+        goto green;
 
-        if (acl_permits (frame, fd->inode, POSIX_ACL_READ))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, fd->inode, POSIX_ACL_READ))
+        goto green;
+    else
+        goto red;
 
 green:
-        STACK_WIND (frame, posix_acl_readv_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv,
-                    fd, size, offset, flags, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_readv_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (readv, frame, -1, EACCES, NULL, 0, NULL, NULL,
-                             NULL);
-        return 0;
+    STACK_UNWIND_STRICT(readv, frame, -1, EACCES, NULL, 0, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno,
-                      struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+posix_acl_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno,
-                             prebuf, postbuf, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf,
+                        xdata);
+    return 0;
 }
 
-
 int
-posix_acl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  struct iovec *vector, int count, off_t offset,
-                  uint32_t flags, struct iobref *iobref, dict_t *xdata)
+posix_acl_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 struct iovec *vector, int count, off_t offset, uint32_t flags,
+                 struct iobref *iobref, dict_t *xdata)
 {
-        if (__is_fuse_call (frame))
-                goto green;
+    if (__is_fuse_call(frame))
+        goto green;
 
-        if (acl_permits (frame, fd->inode, POSIX_ACL_WRITE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, fd->inode, POSIX_ACL_WRITE))
+        goto green;
+    else
+        goto red;
 
 green:
-        STACK_WIND (frame, posix_acl_writev_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev,
-                    fd, vector, count, offset, flags, iobref, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_writev_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
+               flags, iobref, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (writev, frame, -1, EACCES, NULL, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(writev, frame, -1, EACCES, NULL, NULL, NULL);
+    return 0;
 }
 
-
-
 int
-posix_acl_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *prebuf,
-                         struct iatt *postbuf, dict_t *xdata)
+posix_acl_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno,
-                             prebuf, postbuf, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(ftruncate, frame, op_ret, op_errno, prebuf, postbuf,
+                        xdata);
+    return 0;
 }
 
-
 int
-posix_acl_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     off_t offset, dict_t *xdata)
+posix_acl_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                    dict_t *xdata)
 {
-        if (__is_fuse_call (frame))
-                goto green;
+    if (__is_fuse_call(frame))
+        goto green;
 
-        if (acl_permits (frame, fd->inode, POSIX_ACL_WRITE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, fd->inode, POSIX_ACL_WRITE))
+        goto green;
+    else
+        goto red;
 
 green:
-        STACK_WIND (frame, posix_acl_ftruncate_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate,
-                    fd, offset, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_ftruncate_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (ftruncate, frame, -1, EACCES, NULL, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(ftruncate, frame, -1, EACCES, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+posix_acl_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata);
+    STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata)
+posix_acl_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                  dict_t *xdata)
 {
-        if (acl_permits (frame, loc->inode, POSIX_ACL_READ))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->inode, POSIX_ACL_READ))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_opendir_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir,
-                    loc, fd, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_opendir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->opendir, loc, fd, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (opendir, frame, -1, EACCES, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(opendir, frame, -1, EACCES, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_mkdir_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)
+posix_acl_mkdir_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)
 {
-        if (op_ret != 0)
-                goto unwind;
+    if (op_ret != 0)
+        goto unwind;
 
-        posix_acl_ctx_update (inode, this, buf, GF_FOP_MKDIR);
+    posix_acl_ctx_update(inode, this, buf, GF_FOP_MKDIR);
 
 unwind:
-        STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent,
+                        postparent, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-                 mode_t umask, dict_t *xdata)
+posix_acl_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                mode_t umask, dict_t *xdata)
 {
-        mode_t   newmode = 0;
+    mode_t newmode = 0;
 
-        newmode = mode;
-        if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    newmode = mode;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_WRITE | POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 green:
-        newmode = posix_acl_inherit_dir (this, loc, xdata, mode, umask);
+    newmode = posix_acl_inherit_dir(this, loc, xdata, mode, umask);
 
-        STACK_WIND (frame, posix_acl_mkdir_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir,
-                    loc, newmode, umask, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_mkdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->mkdir, loc, newmode, umask, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (mkdir, frame, -1, EACCES, NULL, NULL, NULL, NULL,
-                             NULL);
-        return 0;
+    STACK_UNWIND_STRICT(mkdir, frame, -1, EACCES, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_mknod_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)
+posix_acl_mknod_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)
 {
-        if (op_ret != 0)
-                goto unwind;
+    if (op_ret != 0)
+        goto unwind;
 
-        posix_acl_ctx_update (inode, this, buf, GF_FOP_MKNOD);
+    posix_acl_ctx_update(inode, this, buf, GF_FOP_MKNOD);
 
 unwind:
-        STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(mknod, frame, op_ret, op_errno, inode, buf, preparent,
+                        postparent, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-                 dev_t rdev, mode_t umask, dict_t *xdata)
+posix_acl_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        mode_t  newmode = 0;
+    mode_t newmode = 0;
 
-        newmode = mode;
-        if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    newmode = mode;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_WRITE | POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 green:
-        newmode = posix_acl_inherit_file (this, loc, xdata, mode, umask);
+    newmode = posix_acl_inherit_file(this, loc, xdata, mode, umask);
 
-        STACK_WIND (frame, posix_acl_mknod_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,
-                    loc, newmode, rdev, umask, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_mknod_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->mknod, loc, newmode, rdev, umask,
+               xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (mknod, frame, -1, EACCES, NULL, NULL, NULL, NULL,
-                             NULL);
-        return 0;
+    STACK_UNWIND_STRICT(mknod, frame, -1, EACCES, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, fd_t *fd, inode_t *inode,
-                      struct iatt *buf, struct iatt *preparent,
-                      struct iatt *postparent, dict_t *xdata)
+posix_acl_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, fd_t *fd, inode_t *inode,
+                     struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        if (op_ret != 0)
-                goto unwind;
+    if (op_ret != 0)
+        goto unwind;
 
-        posix_acl_ctx_update (inode, this, buf, GF_FOP_CREATE);
+    posix_acl_ctx_update(inode, this, buf, GF_FOP_CREATE);
 
 unwind:
-        STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf,
+                        preparent, postparent, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-                  mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+posix_acl_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+                 mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        mode_t  newmode = 0;
+    mode_t newmode = 0;
 
-        newmode = mode;
-        if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    newmode = mode;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_WRITE | POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 green:
-        newmode = posix_acl_inherit_file (this, loc, xdata, mode, umask);
+    newmode = posix_acl_inherit_file(this, loc, xdata, mode, umask);
 
-        STACK_WIND (frame, posix_acl_create_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->create,
-                    loc, flags, newmode, umask, fd, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_create_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->create, loc, flags, newmode, umask, fd,
+               xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (create, frame, -1, EACCES, NULL, NULL, NULL,
-                             NULL, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(create, frame, -1, EACCES, NULL, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
-
 int
-posix_acl_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+posix_acl_symlink_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)
 {
-        if (op_ret != 0)
-                goto unwind;
+    if (op_ret != 0)
+        goto unwind;
 
-        posix_acl_ctx_update (inode, this, buf, GF_FOP_SYMLINK);
+    posix_acl_ctx_update(inode, this, buf, GF_FOP_SYMLINK);
 
 unwind:
-        STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent,
+                        postparent, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_symlink (call_frame_t *frame, xlator_t *this, const char *linkname,
-                   loc_t *loc, mode_t umask, dict_t *xdata)
+posix_acl_symlink(call_frame_t *frame, xlator_t *this, const char *linkname,
+                  loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_WRITE | POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_symlink_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink,
-                    linkname, loc, umask, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_symlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (symlink, frame, -1, EACCES, NULL, NULL, NULL,
-                             NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(symlink, frame, -1, EACCES, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
-
 int
-posix_acl_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)
+posix_acl_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)
 {
-        STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent,
+                        xdata);
+    return 0;
 }
 
-
 int
-posix_acl_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-                  dict_t *xdata)
+posix_acl_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+                 dict_t *xdata)
 {
-        if (!sticky_permits (frame, loc->parent, loc->inode))
-                goto red;
+    if (!sticky_permits(frame, loc->parent, loc->inode))
+        goto red;
 
-        if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_WRITE | POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_unlink_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink,
-                    loc, xflag, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_unlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (unlink, frame, -1, EACCES, NULL, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(unlink, frame, -1, EACCES, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno,
-                     struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+posix_acl_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent,
+                        xdata);
+    return 0;
 }
 
-
 int
-posix_acl_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata)
+posix_acl_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+                dict_t *xdata)
 {
-        if (!sticky_permits (frame, loc->parent, loc->inode))
-                goto red;
+    if (!sticky_permits(frame, loc->parent, loc->inode))
+        goto red;
 
-        if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->parent, POSIX_ACL_WRITE | POSIX_ACL_EXECUTE))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_rmdir_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir,
-                    loc, flags, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_rmdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->rmdir, loc, flags, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (rmdir, frame, -1, EACCES, NULL, NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(rmdir, frame, -1, EACCES, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-posix_acl_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *buf,
-                      struct iatt *preoldparent, struct iatt *postoldparent,
-                      struct iatt *prenewparent, struct iatt *postnewparent,
-                      dict_t *xdata)
+posix_acl_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *buf,
+                     struct iatt *preoldparent, struct iatt *postoldparent,
+                     struct iatt *prenewparent, struct iatt *postnewparent,
+                     dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf,
-                             preoldparent, postoldparent,
-                             prenewparent, postnewparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(rename, frame, op_ret, op_errno, buf, preoldparent,
+                        postoldparent, prenewparent, postnewparent, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_rename (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, dict_t *xdata)
+posix_acl_rename(call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new,
+                 dict_t *xdata)
 {
-        if (!acl_permits (frame, old->parent, POSIX_ACL_WRITE))
-                goto red;
+    if (!acl_permits(frame, old->parent, POSIX_ACL_WRITE))
+        goto red;
 
-        if (!acl_permits (frame, new->parent, POSIX_ACL_WRITE))
-                goto red;
+    if (!acl_permits(frame, new->parent, POSIX_ACL_WRITE))
+        goto red;
 
-        if (!sticky_permits (frame, old->parent, old->inode))
-                goto red;
+    if (!sticky_permits(frame, old->parent, old->inode))
+        goto red;
 
-        if (new->inode) {
-                if (!sticky_permits (frame, new->parent, new->inode))
-                        goto red;
-        }
+    if (new->inode) {
+        if (!sticky_permits(frame, new->parent, new->inode))
+            goto red;
+    }
 
-        STACK_WIND (frame, posix_acl_rename_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename,
-                    old, new, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_rename_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->rename, old, new, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (rename, frame, -1, EACCES, NULL, NULL, NULL, NULL,
-                             NULL, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(rename, frame, -1, EACCES, NULL, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
-
 int
-posix_acl_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)
+posix_acl_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)
 {
-        STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent,
+                        postparent, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_link (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, dict_t *xdata)
+posix_acl_link(call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new,
+               dict_t *xdata)
 {
-        struct posix_acl_ctx *ctx = NULL;
-        int                   op_errno = 0;
+    struct posix_acl_ctx *ctx = NULL;
+    int op_errno = 0;
 
-        ctx = posix_acl_ctx_get (old->inode, this);
-        if (!ctx) {
-                op_errno = EIO;
-                goto red;
-        }
+    ctx = posix_acl_ctx_get(old->inode, this);
+    if (!ctx) {
+        op_errno = EIO;
+        goto red;
+    }
 
-        if (!acl_permits (frame, new->parent, POSIX_ACL_WRITE)) {
-                op_errno = EACCES;
-                goto red;
-        }
+    if (!acl_permits(frame, new->parent, POSIX_ACL_WRITE)) {
+        op_errno = EACCES;
+        goto red;
+    }
 
-        if (!sticky_permits (frame, new->parent, new->inode)) {
-                op_errno = EACCES;
-                goto red;
-        }
+    if (!sticky_permits(frame, new->parent, new->inode)) {
+        op_errno = EACCES;
+        goto red;
+    }
 
-        STACK_WIND (frame, posix_acl_link_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,
-                    old, new, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_link_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->link, old, new, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                             NULL);
+    STACK_UNWIND_STRICT(link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, gf_dirent_t *entries,
-                       dict_t *xdata)
+posix_acl_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, gf_dirent_t *entries,
+                      dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                   off_t offset, dict_t *xdata)
+posix_acl_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                  off_t offset, dict_t *xdata)
 {
-        if (acl_permits (frame, fd->inode, POSIX_ACL_READ))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, fd->inode, POSIX_ACL_READ))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_readdir_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir,
-                    fd, size, offset, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_readdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (readdir, frame, -1, EACCES, NULL, NULL);
+    STACK_UNWIND_STRICT(readdir, frame, -1, EACCES, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, gf_dirent_t *entries,
-                        dict_t *xdata)
+posix_acl_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;
-        struct posix_acl     *acl_access  = NULL;
-        struct posix_acl     *acl_default = NULL;
-        struct posix_acl_ctx *ctx         = NULL;
-        data_t               *data        = NULL;
-        int                   ret         = 0;
+    gf_dirent_t *entry = NULL;
+    struct posix_acl *acl_access = NULL;
+    struct posix_acl *acl_default = NULL;
+    struct posix_acl_ctx *ctx = NULL;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (op_ret <= 0)
-                goto unwind;
+    if (op_ret <= 0)
+        goto unwind;
 
-        list_for_each_entry (entry, &entries->list, list) {
-                /* Update the inode ctx */
-                if (!entry->dict || !entry->inode)
-                        continue;
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        /* Update the inode ctx */
+        if (!entry->dict || !entry->inode)
+            continue;
 
-                ctx = posix_acl_ctx_new (entry->inode, this);
-                if (!ctx) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
+        ctx = posix_acl_ctx_new(entry->inode, this);
+        if (!ctx) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                ret = posix_acl_get (entry->inode, this,
-                                     &acl_access, &acl_default);
+        ret = posix_acl_get(entry->inode, this, &acl_access, &acl_default);
 
-                data = dict_get (entry->dict, POSIX_ACL_ACCESS_XATTR);
-                if (!data)
-                        goto acl_default;
+        data = dict_get(entry->dict, POSIX_ACL_ACCESS_XATTR);
+        if (!data)
+            goto acl_default;
 
-                if (acl_access &&
-                    posix_acl_matches_xattr (this, acl_access, data->data,
-                                             data->len))
-                        goto acl_default;
+        if (acl_access &&
+            posix_acl_matches_xattr(this, acl_access, data->data, data->len))
+            goto acl_default;
 
-		if (acl_access)
-			posix_acl_unref(this, acl_access);
+        if (acl_access)
+            posix_acl_unref(this, acl_access);
 
-                acl_access = posix_acl_from_xattr (this, data->data,
-                                                   data->len);
+        acl_access = posix_acl_from_xattr(this, data->data, data->len);
 
-        acl_default:
-                data = dict_get (entry->dict, POSIX_ACL_DEFAULT_XATTR);
-                if (!data)
-                        goto acl_set;
+    acl_default:
+        data = dict_get(entry->dict, POSIX_ACL_DEFAULT_XATTR);
+        if (!data)
+            goto acl_set;
 
-                if (acl_default &&
-                    posix_acl_matches_xattr (this, acl_default, data->data,
-                                             data->len))
-                        goto acl_set;
+        if (acl_default &&
+            posix_acl_matches_xattr(this, acl_default, data->data, data->len))
+            goto acl_set;
 
-		if (acl_default)
-			posix_acl_unref(this, acl_default);
+        if (acl_default)
+            posix_acl_unref(this, acl_default);
 
-                acl_default = posix_acl_from_xattr (this, data->data,
-                                                    data->len);
+        acl_default = posix_acl_from_xattr(this, data->data, data->len);
 
-        acl_set:
-                posix_acl_ctx_update (entry->inode, this, &entry->d_stat,
-                                      GF_FOP_READDIRP);
+    acl_set:
+        posix_acl_ctx_update(entry->inode, this, &entry->d_stat,
+                             GF_FOP_READDIRP);
 
-                ret = posix_acl_set (entry->inode, this,
-                                     acl_access, acl_default);
-                if (ret)
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "failed to set ACL in context");
+        ret = posix_acl_set(entry->inode, this, acl_access, acl_default);
+        if (ret)
+            gf_log(this->name, GF_LOG_WARNING, "failed to set ACL in context");
 
-		if (acl_access)
-			posix_acl_unref(this, acl_access);
-		if (acl_default)
-			posix_acl_unref(this, acl_default);
-        }
+        if (acl_access)
+            posix_acl_unref(this, acl_access);
+        if (acl_default)
+            posix_acl_unref(this, acl_default);
+    }
 
 unwind:
-        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
-
 int
-posix_acl_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                    off_t offset, dict_t *dict)
+posix_acl_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                   off_t offset, dict_t *dict)
 {
-        int ret = 0;
-	dict_t *alloc_dict = NULL;
+    int ret = 0;
+    dict_t *alloc_dict = NULL;
 
-        if (acl_permits (frame, fd->inode, POSIX_ACL_READ))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, fd->inode, POSIX_ACL_READ))
+        goto green;
+    else
+        goto red;
 green:
-	if (!dict)
-		dict = alloc_dict = dict_new ();
-
-        if (dict) {
-                ret = dict_set_int8 (dict, POSIX_ACL_ACCESS_XATTR, 0);
-                if (ret)
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "failed to set key %s",
-                                POSIX_ACL_ACCESS_XATTR);
-
-                ret = dict_set_int8 (dict, POSIX_ACL_DEFAULT_XATTR, 0);
-                if (ret)
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "failed to set key %s",
-                                POSIX_ACL_DEFAULT_XATTR);
-        }
+    if (!dict)
+        dict = alloc_dict = dict_new();
+
+    if (dict) {
+        ret = dict_set_int8(dict, POSIX_ACL_ACCESS_XATTR, 0);
+        if (ret)
+            gf_log(this->name, GF_LOG_WARNING, "failed to set key %s",
+                   POSIX_ACL_ACCESS_XATTR);
 
-        STACK_WIND (frame, posix_acl_readdirp_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp,
-                    fd, size, offset, dict);
+        ret = dict_set_int8(dict, POSIX_ACL_DEFAULT_XATTR, 0);
+        if (ret)
+            gf_log(this->name, GF_LOG_WARNING, "failed to set key %s",
+                   POSIX_ACL_DEFAULT_XATTR);
+    }
 
-	if (alloc_dict)
-		dict_unref (alloc_dict);
-        return 0;
+    STACK_WIND(frame, posix_acl_readdirp_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readdirp, fd, size, offset, dict);
+
+    if (alloc_dict)
+        dict_unref(alloc_dict);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (readdirp, frame, -1, EACCES, NULL, NULL);
+    STACK_UNWIND_STRICT(readdirp, frame, -1, EACCES, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-setattr_scrutiny (call_frame_t *frame, inode_t *inode, struct iatt *buf,
-                  int valid)
+setattr_scrutiny(call_frame_t *frame, inode_t *inode, struct iatt *buf,
+                 int valid)
 {
-        struct posix_acl_ctx   *ctx = NULL;
-
-        if (frame_is_super_user (frame))
-                return 0;
+    struct posix_acl_ctx *ctx = NULL;
 
-        ctx = posix_acl_ctx_get (inode, frame->this);
-        if (!ctx)
-                return EIO;
-
-        if (valid & GF_SET_ATTR_MODE) {
-/*
-       The effective UID of the calling process must match the  owner  of  the
-       file,  or  the  process  must  be  privileged
-*/
-                if (!frame_is_user (frame, ctx->uid))
-                        return EPERM;
-/*
-       If the calling process is not privileged  (Linux:  does  not  have  the
-       CAP_FSETID  capability),  and  the group of the file does not match the
-       effective group ID of the process or one  of  its  supplementary  group
-       IDs,  the  S_ISGID  bit  will be turned off, but this will not cause an
-       error to be returned.
+    if (frame_is_super_user(frame))
+        return 0;
 
-*/
-                if (!frame_in_group (frame, ctx->gid))
-                        buf->ia_prot.sgid = 0;
-        }
+    ctx = posix_acl_ctx_get(inode, frame->this);
+    if (!ctx)
+        return EIO;
 
-        if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) {
-/*
-       Changing timestamps is permitted when: either the process has appropri?
-       ate  privileges,  or  the  effective  user ID equals the user ID of the
-       file, or times is NULL and the process has  write  permission  for  the
-       file.
-*/
-                if (!frame_is_user (frame, ctx->uid) &&
-                    !acl_permits (frame, inode, POSIX_ACL_WRITE))
-                        return EACCES;
-        }
+    if (valid & GF_SET_ATTR_MODE) {
+        /*
+               The effective UID of the calling process must match the  owner of
+           the file,  or  the  process  must  be  privileged
+        */
+        if (!frame_is_user(frame, ctx->uid))
+            return EPERM;
+        /*
+               If the calling process is not privileged  (Linux:  does  not have
+           the CAP_FSETID  capability),  and  the group of the file does not
+           match the effective group ID of the process or one  of  its
+           supplementary  group IDs,  the  S_ISGID  bit  will be turned off, but
+           this will not cause an error to be returned.
+
+        */
+        if (!frame_in_group(frame, ctx->gid))
+            buf->ia_prot.sgid = 0;
+    }
+
+    if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) {
+        /*
+               Changing timestamps is permitted when: either the process has
+           appropri? ate  privileges,  or  the  effective  user ID equals the
+           user ID of the file, or times is NULL and the process has  write
+           permission  for  the file.
+        */
+        if (!frame_is_user(frame, ctx->uid) &&
+            !acl_permits(frame, inode, POSIX_ACL_WRITE))
+            return EACCES;
+    }
 
-        if (valid & GF_SET_ATTR_UID) {
-                if ((!frame_is_super_user (frame)) &&
-                    (buf->ia_uid != ctx->uid))
-                        return EPERM;
-        }
+    if (valid & GF_SET_ATTR_UID) {
+        if ((!frame_is_super_user(frame)) && (buf->ia_uid != ctx->uid))
+            return EPERM;
+    }
 
-        if (valid & GF_SET_ATTR_GID) {
-                if (!frame_is_user (frame, ctx->uid))
-                        return EPERM;
-                if (!frame_in_group (frame, buf->ia_gid))
-                        return EPERM;
-        }
+    if (valid & GF_SET_ATTR_GID) {
+        if (!frame_is_user(frame, ctx->uid))
+            return EPERM;
+        if (!frame_in_group(frame, buf->ia_gid))
+            return EPERM;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_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)
+posix_acl_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)
 {
-        inode_t   *inode = NULL;
+    inode_t *inode = NULL;
 
-        inode = frame->local;
-        frame->local = NULL;
+    inode = frame->local;
+    frame->local = NULL;
 
-        if (op_ret != 0)
-                goto unwind;
+    if (op_ret != 0)
+        goto unwind;
 
-        posix_acl_ctx_update (inode, this, postbuf, GF_FOP_SETATTR);
+    posix_acl_ctx_update(inode, this, postbuf, GF_FOP_SETATTR);
 
 unwind:
-        STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, prebuf,
-                             postbuf, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(setattr, frame, op_ret, op_errno, prebuf, postbuf,
+                        xdata);
+    return 0;
 }
 
-
 int
-posix_acl_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                   struct iatt *buf, int valid, dict_t *xdata)
+posix_acl_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                  struct iatt *buf, int valid, dict_t *xdata)
 {
-        int  op_errno = 0;
+    int op_errno = 0;
 
-        op_errno = setattr_scrutiny (frame, loc->inode, buf, valid);
+    op_errno = setattr_scrutiny(frame, loc->inode, buf, valid);
 
-        if (op_errno)
-                goto red;
+    if (op_errno)
+        goto red;
 
-        frame->local = loc->inode;
+    frame->local = loc->inode;
 
-        STACK_WIND (frame, posix_acl_setattr_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr,
-                    loc, buf, valid, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_setattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->setattr, loc, buf, valid, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    STACK_UNWIND_STRICT(setattr, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_fsetattr_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)
+posix_acl_fsetattr_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)
 {
-        inode_t   *inode = NULL;
+    inode_t *inode = NULL;
 
-        inode = frame->local;
-        frame->local = NULL;
+    inode = frame->local;
+    frame->local = NULL;
 
-        if (op_ret != 0)
-                goto unwind;
+    if (op_ret != 0)
+        goto unwind;
 
-        posix_acl_ctx_update (inode, this, postbuf, GF_FOP_FSETATTR);
+    posix_acl_ctx_update(inode, this, postbuf, GF_FOP_FSETATTR);
 
 unwind:
-        STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, prebuf,
-                             postbuf, xdata);
-        return 0;
+    STACK_UNWIND_STRICT(fsetattr, frame, op_ret, op_errno, prebuf, postbuf,
+                        xdata);
+    return 0;
 }
 
-
 int
-posix_acl_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    struct iatt *buf, int valid, dict_t *xdata)
+posix_acl_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                   struct iatt *buf, int valid, dict_t *xdata)
 {
-        int  op_errno = 0;
+    int op_errno = 0;
 
-        op_errno = setattr_scrutiny (frame, fd->inode, buf, valid);
+    op_errno = setattr_scrutiny(frame, fd->inode, buf, valid);
 
-        if (op_errno)
-                goto red;
+    if (op_errno)
+        goto red;
 
-        frame->local = fd->inode;
+    frame->local = fd->inode;
 
-        STACK_WIND (frame, posix_acl_fsetattr_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr,
-                    fd, buf, valid, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_fsetattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsetattr, fd, buf, valid, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (fsetattr, frame, -1, EACCES, NULL, NULL, NULL);
+    STACK_UNWIND_STRICT(fsetattr, frame, -1, EACCES, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-setxattr_scrutiny (call_frame_t *frame, inode_t *inode, dict_t *xattr)
+setxattr_scrutiny(call_frame_t *frame, inode_t *inode, dict_t *xattr)
 {
-        struct posix_acl_ctx   *ctx = NULL;
-        int                     found = 0;
+    struct posix_acl_ctx *ctx = NULL;
+    int found = 0;
 
-        if (frame_is_super_user (frame))
-                return 0;
+    if (frame_is_super_user(frame))
+        return 0;
 
-        ctx = posix_acl_ctx_get (inode, frame->this);
-        if (!ctx)
-                return EIO;
+    ctx = posix_acl_ctx_get(inode, frame->this);
+    if (!ctx)
+        return EIO;
 
-        if (dict_get (xattr, POSIX_ACL_ACCESS_XATTR) ||
-            dict_get (xattr, POSIX_ACL_DEFAULT_XATTR) ||
-            dict_get (xattr, GF_POSIX_ACL_ACCESS) ||
-            dict_get (xattr, GF_POSIX_ACL_DEFAULT)) {
-                found = 1;
-                if (!frame_is_user (frame, ctx->uid))
-                        return EPERM;
-        }
+    if (dict_get(xattr, POSIX_ACL_ACCESS_XATTR) ||
+        dict_get(xattr, POSIX_ACL_DEFAULT_XATTR) ||
+        dict_get(xattr, GF_POSIX_ACL_ACCESS) ||
+        dict_get(xattr, GF_POSIX_ACL_DEFAULT)) {
+        found = 1;
+        if (!frame_is_user(frame, ctx->uid))
+            return EPERM;
+    }
 
-        if (!found && !acl_permits (frame, inode, POSIX_ACL_WRITE))
-                return EACCES;
+    if (!found && !acl_permits(frame, inode, POSIX_ACL_WRITE))
+        return EACCES;
 
-        return 0;
+    return 0;
 }
 
-
 struct posix_acl *
-posix_acl_xattr_update (xlator_t *this, inode_t *inode, dict_t *xattr,
-                        char *name, struct posix_acl *old)
+posix_acl_xattr_update(xlator_t *this, inode_t *inode, dict_t *xattr,
+                       char *name, struct posix_acl *old)
 {
-        struct  posix_acl      *acl = NULL;
-        data_t                 *data = NULL;
+    struct posix_acl *acl = NULL;
+    data_t *data = NULL;
 
-        data = dict_get (xattr, name);
-        if (data) {
-                acl = posix_acl_from_xattr (this, data->data,
-                                            data->len);
-        }
+    data = dict_get(xattr, name);
+    if (data) {
+        acl = posix_acl_from_xattr(this, data->data, data->len);
+    }
 
-        if (!acl && old)
-                acl = posix_acl_ref (this, old);
+    if (!acl && old)
+        acl = posix_acl_ref(this, old);
 
-        return acl;
+    return acl;
 }
 
-
 int
-posix_acl_setxattr_update (xlator_t *this, inode_t *inode, dict_t *xattr)
+posix_acl_setxattr_update(xlator_t *this, inode_t *inode, dict_t *xattr)
 {
-        struct posix_acl     *acl_access = NULL;
-        struct posix_acl     *acl_default = NULL;
-        struct posix_acl     *old_access = NULL;
-        struct posix_acl     *old_default = NULL;
-        struct posix_acl_ctx *ctx = NULL;
-        int                   ret = 0;
+    struct posix_acl *acl_access = NULL;
+    struct posix_acl *acl_default = NULL;
+    struct posix_acl *old_access = NULL;
+    struct posix_acl *old_default = NULL;
+    struct posix_acl_ctx *ctx = NULL;
+    int ret = 0;
 
-        ctx = posix_acl_ctx_get (inode, this);
-        if (!ctx)
-                return -1;
+    ctx = posix_acl_ctx_get(inode, this);
+    if (!ctx)
+        return -1;
 
-        ret = posix_acl_get (inode, this, &old_access, &old_default);
+    ret = posix_acl_get(inode, this, &old_access, &old_default);
 
-        acl_access = posix_acl_xattr_update (this, inode, xattr,
-                                             POSIX_ACL_ACCESS_XATTR,
-                                             old_access);
+    acl_access = posix_acl_xattr_update(this, inode, xattr,
+                                        POSIX_ACL_ACCESS_XATTR, old_access);
 
-        acl_default = posix_acl_xattr_update (this, inode, xattr,
-                                              POSIX_ACL_DEFAULT_XATTR,
-                                              old_default);
+    acl_default = posix_acl_xattr_update(this, inode, xattr,
+                                         POSIX_ACL_DEFAULT_XATTR, old_default);
 
-        ret = posix_acl_set (inode, this, acl_access, acl_default);
+    ret = posix_acl_set(inode, this, acl_access, acl_default);
 
-        if (acl_access && acl_access != old_access) {
-                posix_acl_access_set_mode (acl_access, ctx);
-        }
+    if (acl_access && acl_access != old_access) {
+        posix_acl_access_set_mode(acl_access, ctx);
+    }
 
-        if (acl_access)
-                posix_acl_unref (this, acl_access);
-        if (acl_default)
-                posix_acl_unref (this, acl_default);
-        if (old_access)
-                posix_acl_unref (this, old_access);
-        if (old_default)
-                posix_acl_unref (this, old_default);
+    if (acl_access)
+        posix_acl_unref(this, acl_access);
+    if (acl_default)
+        posix_acl_unref(this, acl_default);
+    if (old_access)
+        posix_acl_unref(this, old_access);
+    if (old_default)
+        posix_acl_unref(this, old_default);
 
-        return ret;
+    return ret;
 }
 
 /* *
@@ -2094,400 +1999,376 @@ posix_acl_setxattr_update (xlator_t *this, inode_t *inode, dict_t *xattr)
  * access-control translator
  */
 int
-handling_other_acl_related_xattr (xlator_t *this, inode_t *inode, dict_t *xattr)
+handling_other_acl_related_xattr(xlator_t *this, inode_t *inode, dict_t *xattr)
 {
-        struct posix_acl       *acl      = NULL;
-        struct posix_acl_ctx   *ctx      = NULL;
-        data_t                 *data     = NULL;
-        int                     ret      = 0;
-
-        if (!this || !xattr || !inode)
-                goto out;
+    struct posix_acl *acl = NULL;
+    struct posix_acl_ctx *ctx = NULL;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = dict_get (xattr, POSIX_ACL_ACCESS_XATTR);
-        if (data) {
-
-                acl = posix_acl_from_xattr (this, data->data, data->len);
-                if (!acl) {
-                        ret = -1;
-                        goto out;
-                }
+    if (!this || !xattr || !inode)
+        goto out;
 
-                ret = posix_acl_set_specific (inode, this, acl, _gf_true);
-                if (ret)
-                        goto out;
+    data = dict_get(xattr, POSIX_ACL_ACCESS_XATTR);
+    if (data) {
+        acl = posix_acl_from_xattr(this, data->data, data->len);
+        if (!acl) {
+            ret = -1;
+            goto out;
+        }
 
-                ctx = posix_acl_ctx_get (inode, this);
-                if (!ctx) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = posix_acl_set_specific(inode, this, acl, _gf_true);
+        if (ret)
+            goto out;
 
-                posix_acl_access_set_mode (acl, ctx);
-                posix_acl_unref (this, acl);
-                acl = NULL;
+        ctx = posix_acl_ctx_get(inode, this);
+        if (!ctx) {
+            ret = -1;
+            goto out;
         }
 
-        data = dict_get (xattr, POSIX_ACL_DEFAULT_XATTR);
-        if (data) {
-                acl = posix_acl_from_xattr (this, data->data, data->len);
-                if (!acl) {
-                        ret = -1;
-                        goto out;
-                }
+        posix_acl_access_set_mode(acl, ctx);
+        posix_acl_unref(this, acl);
+        acl = NULL;
+    }
 
-                ret = posix_acl_set_specific (inode, this, acl, _gf_false);
+    data = dict_get(xattr, POSIX_ACL_DEFAULT_XATTR);
+    if (data) {
+        acl = posix_acl_from_xattr(this, data->data, data->len);
+        if (!acl) {
+            ret = -1;
+            goto out;
         }
 
+        ret = posix_acl_set_specific(inode, this, acl, _gf_false);
+    }
+
 out:
-        if (acl)
-                posix_acl_unref (this, acl);
+    if (acl)
+        posix_acl_unref(this, acl);
 
-        return ret;
+    return ret;
 }
 int
-posix_acl_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
+posix_acl_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xdata)
 {
+    /*
+     * Update the context of posix_acl_translator, if any of
+     * POSIX_ACL_*_XATTR set in the call back
+     */
+    handling_other_acl_related_xattr(this, (inode_t *)cookie, xdata);
 
-        /*
-         * Update the context of posix_acl_translator, if any of
-         * POSIX_ACL_*_XATTR set in the call back
-         */
-        handling_other_acl_related_xattr (this, (inode_t *)cookie, xdata);
-
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata);
+    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    dict_t *xattr, int flags, dict_t *xdata)
+posix_acl_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                   dict_t *xattr, int flags, dict_t *xdata)
 {
-        int  op_errno = 0;
+    int op_errno = 0;
 
-        op_errno = setxattr_scrutiny (frame, loc->inode, xattr);
+    op_errno = setxattr_scrutiny(frame, loc->inode, xattr);
 
-        if (op_errno != 0)
-                goto red;
+    if (op_errno != 0)
+        goto red;
 
-        if (dict_get (xattr, POSIX_ACL_ACCESS_XATTR) ||
-            dict_get (xattr, POSIX_ACL_DEFAULT_XATTR))
-                posix_acl_setxattr_update (this, loc->inode, xattr);
+    if (dict_get(xattr, POSIX_ACL_ACCESS_XATTR) ||
+        dict_get(xattr, POSIX_ACL_DEFAULT_XATTR))
+        posix_acl_setxattr_update(this, loc->inode, xattr);
 
-        /*
-         * inode is required in call back function to update the context
-         * this translator
-         */
-        STACK_WIND_COOKIE (frame, posix_acl_setxattr_cbk, loc->inode,
-                           FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr,
-                           loc, xattr, flags, xdata);
-        return 0;
+    /*
+     * inode is required in call back function to update the context
+     * this translator
+     */
+    STACK_WIND_COOKIE(frame, posix_acl_setxattr_cbk, loc->inode,
+                      FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, loc,
+                      xattr, flags, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, NULL);
+    STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+posix_acl_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata);
+    STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     dict_t *xattr, int flags, dict_t *xdata)
+posix_acl_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                    dict_t *xattr, int flags, dict_t *xdata)
 {
-        int  op_errno = 0;
+    int op_errno = 0;
 
-        op_errno = setxattr_scrutiny (frame, fd->inode, xattr);
+    op_errno = setxattr_scrutiny(frame, fd->inode, xattr);
 
-        if (op_errno != 0)
-                goto red;
+    if (op_errno != 0)
+        goto red;
 
-        if (dict_get (xattr, POSIX_ACL_ACCESS_XATTR) ||
-            dict_get (xattr, POSIX_ACL_DEFAULT_XATTR))
-                posix_acl_setxattr_update (this, fd->inode, xattr);
+    if (dict_get(xattr, POSIX_ACL_ACCESS_XATTR) ||
+        dict_get(xattr, POSIX_ACL_DEFAULT_XATTR))
+        posix_acl_setxattr_update(this, fd->inode, xattr);
 
-        STACK_WIND (frame, posix_acl_fsetxattr_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr,
-                    fd, xattr, flags, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_fsetxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsetxattr, fd, xattr, flags, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, NULL);
+    STACK_UNWIND_STRICT(fsetxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+posix_acl_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, xattr, xdata);
+    STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, xattr, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    const char *name, dict_t *xdata)
+posix_acl_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                   const char *name, dict_t *xdata)
 {
-        if (whitelisted_xattr (name))
-                goto green;
+    if (whitelisted_xattr(name))
+        goto green;
 
-        if (acl_permits (frame, loc->inode, POSIX_ACL_READ))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->inode, POSIX_ACL_READ))
+        goto green;
+    else
+        goto red;
 
 green:
-        STACK_WIND (frame, posix_acl_getxattr_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr,
-                    loc, name, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_getxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
+    return 0;
 
 red:
-        STACK_UNWIND_STRICT (getxattr, frame, -1, EACCES, NULL, NULL);
+    STACK_UNWIND_STRICT(getxattr, frame, -1, EACCES, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+posix_acl_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, xattr, xdata);
+    STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, xattr, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     const char *name, dict_t *xdata)
+posix_acl_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                    const char *name, dict_t *xdata)
 {
-        if (whitelisted_xattr (name))
-                goto green;
+    if (whitelisted_xattr(name))
+        goto green;
 
-        if (acl_permits (frame, fd->inode, POSIX_ACL_READ))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, fd->inode, POSIX_ACL_READ))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_fgetxattr_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr,
-                    fd, name, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_fgetxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (fgetxattr, frame, -1, EACCES, NULL, NULL);
+    STACK_UNWIND_STRICT(fgetxattr, frame, -1, EACCES, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xdata)
+posix_acl_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata);
+    STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                       const char *name, dict_t *xdata)
+posix_acl_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      const char *name, dict_t *xdata)
 {
-        struct  posix_acl_ctx  *ctx = NULL;
-        int                     op_errno = EACCES;
+    struct posix_acl_ctx *ctx = NULL;
+    int op_errno = EACCES;
 
-        if (frame_is_super_user (frame))
-                goto green;
+    if (frame_is_super_user(frame))
+        goto green;
 
-        ctx = posix_acl_ctx_get (loc->inode, this);
-        if (!ctx) {
-                op_errno = EIO;
-                goto red;
-        }
+    ctx = posix_acl_ctx_get(loc->inode, this);
+    if (!ctx) {
+        op_errno = EIO;
+        goto red;
+    }
 
-        if (whitelisted_xattr (name)) {
-                if (!frame_is_user (frame, ctx->uid)) {
-                        op_errno = EPERM;
-                        goto red;
-                }
+    if (whitelisted_xattr(name)) {
+        if (!frame_is_user(frame, ctx->uid)) {
+            op_errno = EPERM;
+            goto red;
         }
+    }
 
-        if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE))
-                goto green;
-        else
-                goto red;
+    if (acl_permits(frame, loc->inode, POSIX_ACL_WRITE))
+        goto green;
+    else
+        goto red;
 green:
-        STACK_WIND (frame, posix_acl_removexattr_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr,
-                    loc, name, xdata);
-        return 0;
+    STACK_WIND(frame, posix_acl_removexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
+    return 0;
 red:
-        STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, NULL);
+    STACK_UNWIND_STRICT(removexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-posix_acl_forget (xlator_t *this, inode_t *inode)
+posix_acl_forget(xlator_t *this, inode_t *inode)
 {
-        struct posix_acl_ctx *ctx = NULL;
+    struct posix_acl_ctx *ctx = NULL;
 
-        ctx = posix_acl_ctx_get (inode, this);
-        if (!ctx)
-                goto out;
+    ctx = posix_acl_ctx_get(inode, this);
+    if (!ctx)
+        goto out;
 
-        if (ctx->acl_access)
-                posix_acl_unref (this, ctx->acl_access);
+    if (ctx->acl_access)
+        posix_acl_unref(this, ctx->acl_access);
 
-        if (ctx->acl_default)
-                posix_acl_unref (this, ctx->acl_default);
+    if (ctx->acl_default)
+        posix_acl_unref(this, ctx->acl_default);
 
-        GF_FREE (ctx);
+    GF_FREE(ctx);
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
-        struct posix_acl_conf *conf = NULL;
+    struct posix_acl_conf *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_OPTION_RECONF ("super-uid", conf->super_uid, options, uint32, err);
+    GF_OPTION_RECONF("super-uid", conf->super_uid, options, uint32, err);
 
-        return 0;
+    return 0;
 err:
-        return -1;
+    return -1;
 }
 
-
 int
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        struct posix_acl_conf   *conf = NULL;
-        struct posix_acl        *minacl = NULL;
-        struct posix_ace        *minace = NULL;
+    struct posix_acl_conf *conf = NULL;
+    struct posix_acl *minacl = NULL;
+    struct posix_ace *minace = NULL;
 
-        conf = GF_CALLOC (1, sizeof (*conf), gf_posix_acl_mt_conf_t);
-        if (!conf) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "out of memory");
-                return -1;
-        }
+    conf = GF_CALLOC(1, sizeof(*conf), gf_posix_acl_mt_conf_t);
+    if (!conf) {
+        gf_log(this->name, GF_LOG_ERROR, "out of memory");
+        return -1;
+    }
 
-        LOCK_INIT (&conf->acl_lock);
+    LOCK_INIT(&conf->acl_lock);
 
-        this->private = conf;
+    this->private = conf;
 
-        minacl = posix_acl_new (this, 3);
-        if (!minacl)
-                return -1;
+    minacl = posix_acl_new(this, 3);
+    if (!minacl)
+        return -1;
 
-        minace = minacl->entries;
-        minace[0].tag = POSIX_ACL_USER_OBJ;
-        minace[1].tag = POSIX_ACL_GROUP_OBJ;
-        minace[2].tag = POSIX_ACL_OTHER;
+    minace = minacl->entries;
+    minace[0].tag = POSIX_ACL_USER_OBJ;
+    minace[1].tag = POSIX_ACL_GROUP_OBJ;
+    minace[2].tag = POSIX_ACL_OTHER;
 
-        conf->minimal_acl = minacl;
+    conf->minimal_acl = minacl;
 
-        GF_OPTION_INIT ("super-uid", conf->super_uid, uint32, err);
+    GF_OPTION_INIT("super-uid", conf->super_uid, uint32, err);
 
-        return 0;
+    return 0;
 err:
-        return -1;
+    return -1;
 }
 
-
 int
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-        struct posix_acl_conf   *conf = NULL;
-        struct posix_acl        *minacl = NULL;
+    struct posix_acl_conf *conf = NULL;
+    struct posix_acl *minacl = NULL;
 
-        conf = this->private;
-        if (!conf)
-                return 0;
-        this->private = NULL;
+    conf = this->private;
+    if (!conf)
+        return 0;
+    this->private = NULL;
 
-        minacl = conf->minimal_acl;
+    minacl = conf->minimal_acl;
 
-        LOCK (&conf->acl_lock);
-        {
-                conf->minimal_acl = NULL;
-        }
-        UNLOCK (&conf->acl_lock);
+    LOCK(&conf->acl_lock);
+    {
+        conf->minimal_acl = NULL;
+    }
+    UNLOCK(&conf->acl_lock);
 
-        LOCK_DESTROY (&conf->acl_lock);
+    LOCK_DESTROY(&conf->acl_lock);
 
-        GF_FREE (minacl);
+    GF_FREE(minacl);
 
-        GF_FREE (conf);
+    GF_FREE(conf);
 
-        return 0;
+    return 0;
 }
 
-
 struct xlator_fops fops = {
-        .lookup           = posix_acl_lookup,
-        .open             = posix_acl_open,
+    .lookup = posix_acl_lookup,
+    .open = posix_acl_open,
 #if FD_MODE_CHECK_IS_IMPLEMENTED
-        .readv            = posix_acl_readv,
-        .writev           = posix_acl_writev,
-        .ftruncate        = posix_acl_ftruncate,
-        .fsetattr         = posix_acl_fsetattr,
-        .fsetxattr        = posix_acl_fsetxattr,
-        .fgetxattr        = posix_acl_fgetxattr,
+    .readv = posix_acl_readv,
+    .writev = posix_acl_writev,
+    .ftruncate = posix_acl_ftruncate,
+    .fsetattr = posix_acl_fsetattr,
+    .fsetxattr = posix_acl_fsetxattr,
+    .fgetxattr = posix_acl_fgetxattr,
 #endif
-        .access           = posix_acl_access,
-        .truncate         = posix_acl_truncate,
-        .mkdir            = posix_acl_mkdir,
-        .mknod            = posix_acl_mknod,
-        .create           = posix_acl_create,
-        .symlink          = posix_acl_symlink,
-        .unlink           = posix_acl_unlink,
-        .rmdir            = posix_acl_rmdir,
-        .rename           = posix_acl_rename,
-        .link             = posix_acl_link,
-        .opendir          = posix_acl_opendir,
-        .readdir          = posix_acl_readdir,
-        .readdirp         = posix_acl_readdirp,
-        .setattr          = posix_acl_setattr,
-        .setxattr         = posix_acl_setxattr,
-        .getxattr         = posix_acl_getxattr,
-        .removexattr      = posix_acl_removexattr,
-};
-
-
-struct xlator_cbks cbks = {
-        .forget           = posix_acl_forget
+    .access = posix_acl_access,
+    .truncate = posix_acl_truncate,
+    .mkdir = posix_acl_mkdir,
+    .mknod = posix_acl_mknod,
+    .create = posix_acl_create,
+    .symlink = posix_acl_symlink,
+    .unlink = posix_acl_unlink,
+    .rmdir = posix_acl_rmdir,
+    .rename = posix_acl_rename,
+    .link = posix_acl_link,
+    .opendir = posix_acl_opendir,
+    .readdir = posix_acl_readdir,
+    .readdirp = posix_acl_readdirp,
+    .setattr = posix_acl_setattr,
+    .setxattr = posix_acl_setxattr,
+    .getxattr = posix_acl_getxattr,
+    .removexattr = posix_acl_removexattr,
 };
 
+struct xlator_cbks cbks = {.forget = posix_acl_forget};
 
 struct volume_options options[] = {
-        { .key  = {"super-uid"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "0",
-          .description = "UID to be treated as super user's id instead of 0",
-        },
-        { .key = {NULL} },
+    {
+        .key = {"super-uid"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "0",
+        .description = "UID to be treated as super user's id instead of 0",
+    },
+    {.key = {NULL}},
 };