Land part 2 of clang-format changes

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

1 files changed, 496 insertions, 474 deletions

diff --git a/tests/features/glfs-lease.c b/tests/features/glfs-lease.c
index 535b3019a8..f781f46c4c 100644
--- a/tests/features/glfs-lease.c
+++ b/tests/features/glfs-lease.c
@@ -8,16 +8,20 @@
 #include <sys/stat.h>
 
 /* Few rules:
- * 1. A client may have multiple lease keys, but a lease key cannot be shared by multiple clients.
- * 2. Lease key can be set before open, or in glfs_lease request. A lease key set like this is
- *    valid for the lifetime of the fd, i.e. a fd cannot have multiple lease key. But a lease key
- *    can be shared across multiple fds.
+ * 1. A client may have multiple lease keys, but a lease key cannot be shared by
+ * multiple clients.
+ * 2. Lease key can be set before open, or in glfs_lease request. A lease key
+ * set like this is valid for the lifetime of the fd, i.e. a fd cannot have
+ * multiple lease key. But a lease key can be shared across multiple fds.
  */
 glfs_t *client1 = NULL, *client2 = NULL, *client3 = NULL, *client4 = NULL;
 glfs_fd_t *fd1 = NULL, *fd2 = NULL, *fd3 = NULL, *fd4 = NULL;
 FILE *log_file = NULL;
-char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1", lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2";
-char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {0,};
+char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1",
+     lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2";
+char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {
+                                                  0,
+};
 char *volname = NULL, *glfs_log_file = NULL;
 
 #define MAX_CLIENTS 4
@@ -28,668 +32,686 @@ char *volname = NULL, *glfs_log_file = NULL;
 #define NONE 0
 
 static void
-recall_cbk (struct glfs_lease lease, void *data);
+recall_cbk(struct glfs_lease lease, void *data);
 
 static int
-set_read_lease (glfs_fd_t *fd, char ld[])
+set_read_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_SET_LEASE;
-        lease.lease_type = GLFS_RD_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, fd);
-        if (ret < 0) {
-                fprintf (log_file, "\n    RD_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Took RD_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, fd);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RD_LEASE");
+    return ret;
 }
 
 static int
-set_write_lease (glfs_fd_t *fd, char ld[])
+set_write_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_SET_LEASE;
-        lease.lease_type = GLFS_RW_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    RW_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Took RW_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RW_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RW_LEASE");
+    return ret;
 }
 
 static int
-get_lease (glfs_fd_t *fd, char ld[])
+get_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_GET_LEASE;
-        lease.lease_type = -1;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    GET_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        if (lease.lease_type == GLFS_RD_LEASE)
-                fprintf (log_file, "\n    Esisting Lease: RD_LEASE");
-        else if (lease.lease_type == GLFS_RW_LEASE)
-                fprintf (log_file, "\n    Esisting Lease: RW_LEASE");
-        else if (lease.lease_type == 3)
-                fprintf (log_file, "\n    Esisting Lease: RD_LEASE|RW_LEASE");
-        else if (lease.lease_type == 0)
-                fprintf (log_file, "\n    Esisting Lease: NONE");
-        else
-                fprintf (log_file, "\n    Existing lease type:%d", lease.lease_type);
-        return lease.lease_type;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_GET_LEASE;
+    lease.lease_type = -1;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    GET_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    if (lease.lease_type == GLFS_RD_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE");
+    else if (lease.lease_type == GLFS_RW_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RW_LEASE");
+    else if (lease.lease_type == 3)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE|RW_LEASE");
+    else if (lease.lease_type == 0)
+        fprintf(log_file, "\n    Esisting Lease: NONE");
+    else
+        fprintf(log_file, "\n    Existing lease type:%d", lease.lease_type);
+    return lease.lease_type;
 }
 
 static int
-unlk_write_lease (glfs_fd_t *fd, char ld[])
+unlk_write_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_UNLK_LEASE;
-        lease.lease_type = GLFS_RW_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    Unlock RW_LESAE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Unlocked RW_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RW_LESAE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RW_LEASE");
+    return ret;
 }
 
 static int
-unlk_read_lease (glfs_fd_t *fd, char ld[])
+unlk_read_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_UNLK_LEASE;
-        lease.lease_type = GLFS_RD_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    Unlock RD_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Unlocked RD_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RD_LEASE");
+    return ret;
 }
 
 glfs_t *
 setup_new_client(char *volname, char *log_fileile)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (log_file, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        if (ret < 0) {
-                fprintf (log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_fileile, 7);
-        if (ret < 0) {
-                fprintf (log_file, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (log_file, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
-        return fs;
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(log_file, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_fileile, 7);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
-#define OPEN(client, flags, fd, lease_id)                                                   \
-do {                                                                                        \
-        int ret_val = 0;                                                                    \
-        ret_val = glfs_setfsleaseid (lease_id);                                          \
-        if (ret_val) {                                                                      \
-                fprintf (log_file, "\nglfs_setfsleaseid failed with ret: %d (%s)\n",        \
-                                ret, strerror (errno));                                     \
-                return -1;                                                                  \
-        }                                                                                   \
-        fd = glfs_open (client, TEST_FILE, flags);                                          \
-        if (fd == NULL) {                                                                   \
-                fprintf (log_file, "\nglfs_open failed with ret: %d (%s)\n",                \
-                                ret, strerror (errno));                                     \
-                return -1;                                                                  \
-        }                                                                                   \
-} while (0)                                                                                 \
-
-#define VERIFY_RESULT(test_case, ret, value)                                                \
-do {                                                                                        \
-        if (ret != value) {                                                                 \
-                fprintf (log_file, "\n    Testcase %d failed, ret = %d, value=%d\n", test_case, ret, value); \
-                goto error; /*test unsuccessful*/                                           \
-        }                                                                                   \
-        fprintf (log_file, "\n    Testcase %d Succeeded\n", test_case);                       \
-} while (0)                                                                                 \
+#define OPEN(client, flags, fd, lease_id)                                      \
+    do {                                                                       \
+        int ret_val = 0;                                                       \
+        ret_val = glfs_setfsleaseid(lease_id);                                 \
+        if (ret_val) {                                                         \
+            fprintf(log_file,                                                  \
+                    "\nglfs_setfsleaseid failed with ret: %d (%s)\n", ret,     \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+        fd = glfs_open(client, TEST_FILE, flags);                              \
+        if (fd == NULL) {                                                      \
+            fprintf(log_file, "\nglfs_open failed with ret: %d (%s)\n", ret,   \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define VERIFY_RESULT(test_case, ret, value)                                   \
+    do {                                                                       \
+        if (ret != value) {                                                    \
+            fprintf(log_file,                                                  \
+                    "\n    Testcase %d failed, ret = %d, value=%d\n",          \
+                    test_case, ret, value);                                    \
+            goto error; /*test unsuccessful*/                                  \
+        }                                                                      \
+        fprintf(log_file, "\n    Testcase %d Succeeded\n", test_case);         \
+    } while (0)
 
 static void
-recall_cbk (struct glfs_lease lease, void *data)
+recall_cbk(struct glfs_lease lease, void *data)
 {
-        int ret = -1;
-        char ld[GLFS_LEASE_ID_SIZE] = "";
+    int ret = -1;
+    char ld[GLFS_LEASE_ID_SIZE] = "";
 
-        fprintf (log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id);
-        memcpy (ld, lease.lease_id, GLFS_LEASE_ID_SIZE);
-        ret = unlk_write_lease ((glfs_fd_t *)data, ld);
-        VERIFY_RESULT (500, ret, SHUD_PASS);
+    fprintf(log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id);
+    memcpy(ld, lease.lease_id, GLFS_LEASE_ID_SIZE);
+    ret = unlk_write_lease((glfs_fd_t *)data, ld);
+    VERIFY_RESULT(500, ret, SHUD_PASS);
 error:
-        return;
+    return;
 }
 
-
 static int
-testcase1_rd_lease ()
+testcase1_rd_lease()
 {
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
 
-	fprintf (log_file, "\n Basic test case for Read lease:");
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDONLY, fd1, lid1);
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_FAIL);
+    fprintf(log_file, "\n Basic test case for Read lease:");
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_FAIL);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, SHUD_FAIL);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_FAIL);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (7, ret, SHUD_FAIL);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, SHUD_FAIL);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase2_wr_lease ()
+testcase2_wr_lease()
 {
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for Write lease:");
-        /* Open fd on client 1 in WRonly mode */
-        OPEN (client1, O_WRONLY, fd1, lid1);
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_FAIL);
+    fprintf(log_file, "\n Basic test case for Write lease:");
+    /* Open fd on client 1 in WRonly mode */
+    OPEN(client1, O_WRONLY, fd1, lid1);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_FAIL);
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, SHUD_FAIL);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_FAIL);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, GLFS_RW_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, GLFS_RW_LEASE);
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (7, ret, SHUD_FAIL);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, SHUD_FAIL);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase3_rd_wr_lease ()
+testcase3_rd_wr_lease()
 {
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for Read Write lease:");
-        /* Open fd on client 1 in WRonly mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    fprintf(log_file, "\n Basic test case for Read Write lease:");
+    /* Open fd on client 1 in WRonly mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE));
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE));
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, GLFS_RD_LEASE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (7, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, NONE);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase4_rd_lease_multi_clnt ()
+testcase4_rd_lease_multi_clnt()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for multi client Read lease:");
+    fprintf(log_file, "\n Basic test case for multi client Read lease:");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDONLY, fd1, lid1);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
 
-        /* Open fd on client 2 in RW mode */
-        OPEN (client2, O_RDONLY, fd2, lid2);
+    /* Open fd on client 2 in RW mode */
+    OPEN(client2, O_RDONLY, fd2, lid2);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = set_read_lease (fd2, lid2);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_read_lease(fd2, lid2);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_read_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = get_lease (fd2, lid2);
-        VERIFY_RESULT (7, ret, NONE);
+    ret = get_lease(fd2, lid2);
+    VERIFY_RESULT(7, ret, NONE);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (9, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(9, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase5_openfd_multi_lid ()
+testcase5_openfd_multi_lid()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        glfs_fd_t *fd3      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for multi lid openfd check:");
+    fprintf(log_file, "\n Basic test case for multi lid openfd check:");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDONLY, fd1, lid1);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
 
-        /* Open fd on client 2 in RW mode */
-        OPEN (client2, O_RDWR, fd2, lid2);
-        OPEN (client2, O_RDWR, fd3, lid2);
+    /* Open fd on client 2 in RW mode */
+    OPEN(client2, O_RDWR, fd2, lid2);
+    OPEN(client2, O_RDWR, fd3, lid2);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(
+        1, ret,
+        SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/
 
-        ret = set_write_lease (fd2, lid2);
-        VERIFY_RESULT (2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(
+        2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        ret = set_write_lease (fd2, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_write_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (6, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
 
-        ret = glfs_close (fd3);
-        VERIFY_RESULT (7, ret, SHUD_PASS);
+    ret = glfs_close(fd3);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase6_openfd_same_lid ()
+testcase6_openfd_same_lid()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        glfs_fd_t *fd3      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for same lid openfd check:");
+    fprintf(log_file, "\n Basic test case for same lid openfd check:");
 
-        /* Open fd on client 2 in RW mode */
-        OPEN (client1, O_RDWR, fd1, lid2);
-        OPEN (client1, O_RDWR, fd2, lid2);
+    /* Open fd on client 2 in RW mode */
+    OPEN(client1, O_RDWR, fd1, lid2);
+    OPEN(client1, O_RDWR, fd2, lid2);
 
-        ret = set_write_lease (fd1, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = set_write_lease (fd2, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = set_read_lease (fd2, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_read_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_write_lease (fd1, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd1, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = unlk_read_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = unlk_write_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (6, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (7, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase7_rd_multi_lid ()
+testcase7_rd_multi_lid()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for multi lease id Read lease:");
+    fprintf(log_file, "\n Basic test case for multi lease id Read lease:");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client2, O_RDONLY, fd1, lid2);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client2, O_RDONLY, fd1, lid2);
 
-        /* Open fd on client 2 in RD mode */
-        OPEN (client2, O_RDONLY, fd2, lid3);
+    /* Open fd on client 2 in RD mode */
+    OPEN(client2, O_RDONLY, fd2, lid3);
 
-        ret = set_read_lease (fd1, lid2);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid2);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = set_read_lease (fd2, lid3);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_read_lease(fd2, lid3);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid2);
-        VERIFY_RESULT (3, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid2);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
 
-        ret = unlk_read_lease (fd1, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_read_lease (fd2, lid3);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd2, lid3);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid2);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid2);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = get_lease (fd2, lid3);
-        VERIFY_RESULT (7, ret, NONE);
+    ret = get_lease(fd2, lid3);
+    VERIFY_RESULT(7, ret, NONE);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (9, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(9, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase8_client_disconnect ()
+testcase8_client_disconnect()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for client disconnect cleanup");
+    fprintf(log_file, "\n Basic test case for client disconnect cleanup");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, GLFS_RD_LEASE);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE));
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE));
 
-        ret = glfs_fini (client1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = glfs_fini(client1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        /* Open fd on client 2 in RD mode */
-        OPEN (client2, O_RDONLY, fd2, lid3);
+    /* Open fd on client 2 in RD mode */
+    OPEN(client2, O_RDONLY, fd2, lid3);
 
-        ret = get_lease (fd2, lid3);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd2, lid3);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (7, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
 
-        client1 = setup_new_client (volname, glfs_log_file);
+    client1 = setup_new_client(volname, glfs_log_file);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase9_recall_conflict_lease ()
+testcase9_recall_conflict_lease()
 {
-        struct glfs_object *obj = NULL;
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
-        struct glfs_lease lease = {0, };
-
-        fprintf (log_file, "\n Basic test case for conflicting lease causing recall");
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_SET_LEASE;
-        lease.lease_type = GLFS_RD_LEASE;
-        memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE);
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
-
-        obj = glfs_h_lookupat (client2, NULL, TEST_FILE, NULL, 0);
-        ret = glfs_h_lease (client2, obj, &lease);
-        VERIFY_RESULT (2, ret, SHUD_FAIL);
-
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
-
-        sleep (3);
-        ret = glfs_h_close (obj);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
-
-        return 0;
+    struct glfs_object *obj = NULL;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+    struct glfs_lease lease = {
+        0,
+    };
+
+    fprintf(log_file,
+            "\n Basic test case for conflicting lease causing recall");
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    obj = glfs_h_lookupat(client2, NULL, TEST_FILE, NULL, 0);
+    ret = glfs_h_lease(client2, obj, &lease);
+    VERIFY_RESULT(2, ret, SHUD_FAIL);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    sleep(3);
+    ret = glfs_h_close(obj);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase10_recall_open_conflict ()
+testcase10_recall_open_conflict()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for conflicting open causing recall");
+    fprintf(log_file, "\n Basic test case for conflicting open causing recall");
 
-        /* Open fd on client 1 in RW mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
+    /* Open fd on client 1 in RW mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        /* Open fd on client 1 in RW mode */
-        OPEN (client2, O_RDWR, fd2, lid2);
+    /* Open fd on client 1 in RW mode */
+    OPEN(client2, O_RDWR, fd2, lid2);
 
-        /* TODO: Check for recall cbk functionality */
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    /* TODO: Check for recall cbk functionality */
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret      = 0;
-        int        i        = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *topdir   = "topdir", *filename = "file1";
-        char      *buf      = NULL;
-        int        x        = 0;
-        ssize_t    xattr_size = -1;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <Vol> <glfs client log file> <testcase log file>\n"
-                                , argv[0]);
-                return -1;
-        }
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    int x = 0;
+    ssize_t xattr_size = -1;
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <Vol> <glfs client log file> "
+                "<testcase log file>\n",
+                argv[0]);
+        return -1;
+    }
 
-        log_file = fopen (argv[3], "w");
-	if (!log_file)
-		goto error;
+    log_file = fopen(argv[3], "w");
+    if (!log_file)
+        goto error;
 
-        volname = argv[1];
-        glfs_log_file = argv[2];
+    volname = argv[1];
+    glfs_log_file = argv[2];
 
-        /* Setup 3 clients */
-        client1 = setup_new_client (volname, glfs_log_file);
-        client2 = setup_new_client (volname, glfs_log_file);
-        client3 = setup_new_client (volname, glfs_log_file);
+    /* Setup 3 clients */
+    client1 = setup_new_client(volname, glfs_log_file);
+    client2 = setup_new_client(volname, glfs_log_file);
+    client3 = setup_new_client(volname, glfs_log_file);
 
-        ret = testcase1_rd_lease ();
-        VERIFY_RESULT (101, ret, SHUD_PASS);
+    ret = testcase1_rd_lease();
+    VERIFY_RESULT(101, ret, SHUD_PASS);
 
-        ret = testcase2_wr_lease ();
-        VERIFY_RESULT (102, ret, SHUD_PASS);
+    ret = testcase2_wr_lease();
+    VERIFY_RESULT(102, ret, SHUD_PASS);
 
-        ret = testcase3_rd_wr_lease ();
-        VERIFY_RESULT (103, ret, SHUD_PASS);
+    ret = testcase3_rd_wr_lease();
+    VERIFY_RESULT(103, ret, SHUD_PASS);
 
-        ret = testcase4_rd_lease_multi_clnt ();
-        VERIFY_RESULT (104, ret, SHUD_PASS);
+    ret = testcase4_rd_lease_multi_clnt();
+    VERIFY_RESULT(104, ret, SHUD_PASS);
 
-        ret = testcase5_openfd_multi_lid ();
-        VERIFY_RESULT (105, ret, SHUD_PASS);
+    ret = testcase5_openfd_multi_lid();
+    VERIFY_RESULT(105, ret, SHUD_PASS);
 
-        ret = testcase6_openfd_same_lid ();
-        VERIFY_RESULT (106, ret, SHUD_PASS);
+    ret = testcase6_openfd_same_lid();
+    VERIFY_RESULT(106, ret, SHUD_PASS);
 
-        ret = testcase7_rd_multi_lid ();
-        VERIFY_RESULT (107, ret, SHUD_PASS);
+    ret = testcase7_rd_multi_lid();
+    VERIFY_RESULT(107, ret, SHUD_PASS);
 
-	ret = testcase8_client_disconnect ();
-        VERIFY_RESULT (108, ret, SHUD_PASS);
+    ret = testcase8_client_disconnect();
+    VERIFY_RESULT(108, ret, SHUD_PASS);
 
-        ret = testcase9_recall_conflict_lease ();
-        VERIFY_RESULT (109, ret, SHUD_PASS);
+    ret = testcase9_recall_conflict_lease();
+    VERIFY_RESULT(109, ret, SHUD_PASS);
 
-        ret = testcase10_recall_open_conflict ();
-        VERIFY_RESULT (110, ret, SHUD_PASS);
+    ret = testcase10_recall_open_conflict();
+    VERIFY_RESULT(110, ret, SHUD_PASS);
 
-        glfs_fini (client1);
-        glfs_fini (client2);
-        glfs_fini (client3);
+    glfs_fini(client1);
+    glfs_fini(client2);
+    glfs_fini(client3);
 
-	fclose (log_file);
-        return 0;
+    fclose(log_file);
+    return 0;
 error:
-        return -1;
+    return -1;
 }