gfapi: object handle based API extensions

There is an ongoing effort to integrate NFS Ganesha (
https://github.com/nfs-ganesha/nfs-ganesha/wiki ) with GlusterFS as one of
the file system back ends.

Towards this we need extensions to gfapi that can handle object based
operations. Meaning, instead of using full paths or relative paths from
cwd, it is required that we can work with APIs, like the *at POSIX
variants, to be able to create, lookup, open etc. files and directories.
Hence the objects are the files or directories themselves and we give out
handles to these objects that can be used for further operations.

This code drop is an initial implementation of the proposed APIs.

The new APIs are implemented as glfs_h_XXX variants in the file
glfs-handleops.c to mirror glfs-fops.c style. The code leverages holding
onto inode references and doling these out as opaque/cookie type objects to
the callers, to enable them to be used as handles in other operations.

An fd based approach was considered, but due to the extra footprint that
the fd structure and its counterparts would incur, this was dropped to take
the approach of holding inode references themselves.

Tested by extending glfsxmp.c to invoke and exercise the added APIs, and
further tested with a reference integration of the same as an FSAL with NFS
Ganesha.

Change-Id: I23629c99e905b54070fa2e6565147812e5f3fa5d
BUG: 1016000
Signed-off-by: R.Shyamsundar <srangana@redhat.com>
Reviewed-on: http://review.gluster.org/5936
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@redhat.com>

1 files changed, 1359 insertions, 5 deletions

diff --git a/api/examples/glfsxmp.c b/api/examples/glfsxmp.c
index 644793a4b..8231a3949 100644
--- a/api/examples/glfsxmp.c
+++ b/api/examples/glfsxmp.c
@@ -1,6 +1,8 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include <errno.h>
 #include "api/glfs.h"
+#include "api/glfs-handles.h"
 #include <string.h>
 #include <time.h>
 
@@ -133,11 +135,1357 @@ test_chdir (glfs_t *fs)
 	return 0;
 }
 
+#ifdef DEBUG
+static void
+peek_stat (struct stat *sb)
+{
+	printf ("Dumping stat information:\n");
+	printf ("File type:                ");
+
+	switch (sb->st_mode & S_IFMT) {
+		case S_IFBLK:  printf ("block device\n");            break;
+		case S_IFCHR:  printf ("character device\n");        break;
+		case S_IFDIR:  printf ("directory\n");               break;
+		case S_IFIFO:  printf ("FIFO/pipe\n");               break;
+		case S_IFLNK:  printf ("symlink\n");                 break;
+		case S_IFREG:  printf ("regular file\n");            break;
+		case S_IFSOCK: printf ("socket\n");                  break;
+		default:       printf ("unknown?\n");                break;
+	}
+
+	printf ("I-node number:            %ld\n", (long) sb->st_ino);
+
+	printf ("Mode:                     %lo (octal)\n",
+		(unsigned long) sb->st_mode);
+
+	printf ("Link count:               %ld\n", (long) sb->st_nlink);
+	printf ("Ownership:                UID=%ld   GID=%ld\n",
+		(long) sb->st_uid, (long) sb->st_gid);
+
+	printf ("Preferred I/O block size: %ld bytes\n",
+		(long) sb->st_blksize);
+	printf ("File size:                %lld bytes\n",
+		(long long) sb->st_size);
+	printf ("Blocks allocated:         %lld\n",
+		(long long) sb->st_blocks);
+
+	printf ("Last status change:       %s", ctime(&sb->st_ctime));
+	printf ("Last file access:         %s", ctime(&sb->st_atime));
+	printf ("Last file modification:   %s", ctime(&sb->st_mtime));
+
+	return;
+}
+
+static void
+peek_handle (unsigned char *glid)
+{
+	int i;
+
+	for (i = 0; i < GFAPI_HANDLE_LENGTH; i++)
+	{
+		printf (":%02x:", glid[i]);
+	}
+	printf ("\n");
+}
+#else /* DEBUG */
+static void
+peek_stat (struct stat *sb)
+{
+	return;
+}
+
+static void
+peek_handle (unsigned char *id)
+{
+	return;
+}
+#endif /* DEBUG */
+
+glfs_t    *fs = NULL;
+char      *full_parent_name = "/testdir", *parent_name = "testdir";
+
+void
+test_h_unlink (void)
+{
+	char               *my_dir = "unlinkdir";
+	char               *my_file = "file.txt";
+	char               *my_subdir = "dir1";
+	struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
+			   *subdir = NULL, *subleaf = NULL;
+	struct stat         sb;
+	int                 ret;
+
+	printf ("glfs_h_unlink tests: In Progress\n");
+
+	/* Prepare tests */
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, NULL, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
+	if (dir == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, parent, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	leaf = glfs_h_creat (fs, dir, my_file, O_CREAT, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, dir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	subdir = glfs_h_mkdir (fs, dir, my_subdir, 0644, &sb);
+	if (subdir == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_subdir, dir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	subleaf = glfs_h_creat (fs, subdir, my_file, O_CREAT, 0644, &sb);
+	if (subleaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, subdir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink non empty directory */
+	ret = glfs_h_unlink (fs, dir, my_subdir);
+	if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
+			 my_subdir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink regular file */
+	ret = glfs_h_unlink (fs, subdir, my_file);
+	if (ret) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+			 my_file, subdir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink directory */
+	ret = glfs_h_unlink (fs, dir, my_subdir);
+	if (ret) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+			 my_subdir, dir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink regular file */
+	ret = glfs_h_unlink (fs, dir, my_file);
+	if (ret) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+			 my_file, dir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink non-existant regular file */
+	ret = glfs_h_unlink (fs, dir, my_file);
+	if ((ret && errno != ENOENT) || (ret == 0)) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking non-existant %s: invalid errno ,%d, %s\n",
+			 my_file, ret, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink non-existant directory */
+	ret = glfs_h_unlink (fs, dir, my_subdir);
+	if ((ret && errno != ENOENT) || (ret == 0)) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking non-existant %s:  invalid errno ,%d, %s\n",
+			 my_subdir, ret, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	/* unlink directory */
+	ret = glfs_h_unlink (fs, parent, my_dir);
+	if (ret) {
+		fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+			 my_dir, dir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+
+	printf ("glfs_h_unlink tests: PASSED\n");
+
+out:
+	if (dir)
+		glfs_h_close (dir);
+	if (leaf)
+		glfs_h_close (leaf);
+	if (subdir)
+		glfs_h_close (subdir);
+	if (subleaf)
+		glfs_h_close (subleaf);
+	if (parent)
+		glfs_h_close (parent);
+
+	return;
+}
+
+void
+test_h_getsetattrs (void)
+{
+	char               *my_dir = "attrdir", *full_dir_path="/testdir/attrdir";
+	char               *my_file = "attrfile.txt";
+	struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+	struct stat         sb, retsb;
+	int                 ret, valid;
+	struct timespec     timestamp;
+
+	printf("glfs_h_getattrs and setattrs tests: In Progress\n");
+
+	/* Prepare tests */
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, NULL, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
+	if (dir == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, parent, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_creat (fs, dir, my_file, O_CREAT, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, dir, strerror (errno));
+		printf ("glfs_h_unlink tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	ret = glfs_h_getattrs (fs, dir, &retsb);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_getattrs: error %s: from (%p),%s\n",
+			 my_dir, dir, strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&retsb);
+	/* TODO: Compare stat information */
+
+	retsb.st_mode = 00666;
+	retsb.st_uid = 1000;
+	retsb.st_gid = 1001;
+	ret = clock_gettime (CLOCK_REALTIME, &timestamp);
+	if(ret != 0) {
+		fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+	retsb.st_atim = timestamp;
+	retsb.st_mtim = timestamp;
+	valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
+	GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
+	peek_stat (&retsb);
+
+	ret = glfs_h_setattrs (fs, dir, &retsb, valid);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_setattrs: error %s: from (%p),%s\n",
+			 my_dir, dir, strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+
+	memset(&retsb, 0, sizeof (struct stat));
+	ret = glfs_h_stat (fs, dir, &retsb);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_stat: error %s: from (%p),%s\n",
+			 my_dir, dir, strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&retsb);
+
+	printf ("glfs_h_getattrs and setattrs tests: PASSED\n");
+out:
+	if (parent)
+		glfs_h_close (parent);
+	if (leaf)
+		glfs_h_close (leaf);
+	if (dir)
+		glfs_h_close (dir);
+
+	return;
+}
+
+void
+test_h_truncate (void)
+{
+	char               *my_dir = "truncatedir";
+	char               *my_file = "file.txt";
+	struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
+	struct stat         sb, retsb;
+	glfs_fd_t          *fd = NULL;
+	char                buf[32];
+	off_t               offset = 0;
+	int                 ret = 0;
+
+	printf("glfs_h_truncate tests: In Progress\n");
+
+	/* Prepare tests */
+	root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (root == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, NULL, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, root, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, parent, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	fd = glfs_h_open (fs, leaf, O_RDWR);
+	if (fd == NULL) {
+		fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
+			 my_file, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+
+	memcpy (buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+	ret = glfs_write (fd, buf, 32, 0);
+
+	/* run tests */
+	/* truncate lower */
+	offset = 30;
+	ret = glfs_h_truncate (fs, leaf, offset);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+			 my_file, parent, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	ret = glfs_h_getattrs (fs, leaf, &sb);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
+			 my_file, leaf, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	if (sb.st_size != offset) {
+		fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+
+	/* truncate higher */
+	offset = 32;
+	ret = glfs_h_truncate (fs, leaf, offset);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+			 my_file, parent, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	ret = glfs_h_getattrs (fs, leaf, &sb);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
+			 my_file, leaf, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	if (sb.st_size != offset) {
+		fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+
+	/* truncate equal */
+	offset = 30;
+	ret = glfs_h_truncate (fs, leaf, offset);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+			 my_file, parent, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	ret = glfs_h_getattrs (fs, leaf, &sb);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
+			 my_file, leaf, strerror (errno));
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+	if (sb.st_size != offset) {
+		fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
+		printf ("glfs_h_truncate tests: FAILED\n");
+		goto out;
+	}
+
+	printf ("glfs_h_truncate tests: PASSED\n");
+out:
+	if (fd)
+		glfs_close (fd);
+	if (root)
+		glfs_h_close (root);
+	if (parent)
+		glfs_h_close (parent);
+	if (leaf)
+		glfs_h_close (leaf);
+
+	return;
+}
+
+void
+test_h_links (void)
+{
+	char               *my_dir = "linkdir", *full_dir_path="/testdir/linkdir";
+	char               *my_file = "file.txt";
+	char               *my_symlnk = "slnk.txt";
+	char               *my_lnk = "lnk.txt";
+	char               *linksrc_dir = "dir1";
+	char               *linktgt_dir = "dir2";
+	struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+	                   *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+	struct glfs_object *ln1 = NULL;
+	struct stat         sb, retsb;
+	int                 ret, valid;
+	char               *buf = NULL;
+
+	printf("glfs_h_link(s) tests: In Progress\n");
+
+	/* Prepare tests */
+	root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (root == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, NULL, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, root, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, parent, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dirsrc = glfs_h_mkdir (fs, parent, linksrc_dir, 0644, &sb);
+	if (dirsrc == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 linksrc_dir, parent, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dirtgt = glfs_h_mkdir (fs, parent, linktgt_dir, 0644, &sb);
+	if (dirtgt == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 linktgt_dir, parent, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dleaf = glfs_h_creat (fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+	if (dleaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, dirsrc, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* run tests */
+	/* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
+	ln1 = glfs_h_symlink (fs, parent, my_symlnk, "./file.txt", &sb);
+	if (ln1 == NULL) {
+		fprintf (stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
+			 my_symlnk, parent, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	buf = calloc (1024, sizeof(char));
+	if (buf == NULL) {
+		fprintf (stderr, "Error allocating memory\n");
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+
+	ret = glfs_h_readlink (fs, ln1, buf, 1024);
+	if (ret <= 0) {
+		fprintf (stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
+			 my_symlnk, ln1, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	if (!(strncmp (buf, my_symlnk, strlen (my_symlnk)))) {
+		fprintf (stderr, "glfs_h_readlink: error mismatch in link name: actual %s: retrieved %s\n",
+			 my_symlnk, buf);
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+
+	/* link: /testdir/linkdir/file.txt to ./lnk.txt */
+	ret = glfs_h_link (fs, leaf, parent, my_lnk);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+			 my_lnk, parent, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	/* TODO: Should write content to a file and read from the link */
+
+	/* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
+	ret = glfs_h_link (fs, dleaf, dirtgt, my_lnk);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+			 my_lnk, dirtgt, strerror (errno));
+		printf ("glfs_h_link(s) tests: FAILED\n");
+		goto out;
+	}
+	/* TODO: Should write content to a file and read from the link */
+
+	printf ("glfs_h_link(s) tests: PASSED\n");
+
+out:
+	if (root)
+		glfs_h_close (root);
+	if (parent)
+		glfs_h_close (parent);
+	if (leaf)
+		glfs_h_close (leaf);
+	if (dirsrc)
+		glfs_h_close (dirsrc);
+	if (dirtgt)
+		glfs_h_close (dirtgt);
+	if (dleaf)
+		glfs_h_close (dleaf);
+	if (ln1)
+		glfs_h_close (ln1);
+	if (buf)
+		free (buf);
+
+	return;
+}
+
+void
+test_h_rename (void)
+{
+	char               *my_dir = "renamedir",
+	                   *full_dir_path="/testdir/renamedir";
+	char               *my_file = "file.txt";
+	char               *src_dir = "dir1";
+	char               *tgt_dir = "dir2";
+	struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+	                   *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+	struct stat         sb, retsb;
+	int                 ret, valid;
+
+	printf("glfs_h_rename tests: In Progress\n");
+
+	/* Prepare tests */
+	root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (root == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, NULL, strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, root, strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, parent, strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dirsrc = glfs_h_mkdir (fs, parent, src_dir, 0644, &sb);
+	if (dirsrc == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 src_dir, parent, strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dirtgt = glfs_h_mkdir (fs, parent, tgt_dir, 0644, &sb);
+	if (dirtgt == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 tgt_dir, parent, strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	dleaf = glfs_h_creat (fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+	if (dleaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+			 my_file, dirsrc, strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* run tests */
+	/* Rename file.txt -> file1.txt */
+	ret = glfs_h_rename (fs, parent, "file.txt", parent, "file1.txt");
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+			 "file.txt", "file1.txt", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	/* rename dir1/file.txt -> file.txt */
+	ret = glfs_h_rename (fs, dirsrc, "file.txt", parent, "file.txt");
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
+			 src_dir, "file.txt", "file.txt", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	/* rename file1.txt -> file.txt (exists) */
+	ret = glfs_h_rename (fs, parent, "file1.txt", parent, "file.txt");
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+			 "file.txt", "file.txt", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	/* rename dir1 -> dir3 */
+	ret = glfs_h_rename (fs, parent, "dir1", parent, "dir3");
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+			 "dir1", "dir3", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	/* rename dir2 ->dir3 (exists) */
+	ret = glfs_h_rename (fs, parent, "dir2", parent, "dir3");
+	if (ret != 0) {
+		fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+			 "dir2", "dir3", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	/* rename file.txt -> dir3 (fail) */
+	ret = glfs_h_rename (fs, parent, "file.txt", parent, "dir3");
+	if (ret == 0) {
+		fprintf (stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+			 "file.txt", "dir3", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	/* rename dir3 -> file.txt (fail) */
+	ret = glfs_h_rename (fs, parent, "dir3", parent, "file.txt");
+	if (ret == 0) {
+		fprintf (stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+			 "dir3", "file.txt", strerror (errno));
+		printf ("glfs_h_rename tests: FAILED\n");
+		goto out;
+	}
+
+	printf ("glfs_h_rename tests: PASSED\n");
+
+out:
+	if (root)
+		glfs_h_close (root);
+	if (parent)
+		glfs_h_close (parent);
+	if (leaf)
+		glfs_h_close (leaf);
+	if (dirsrc)
+		glfs_h_close (dirsrc);
+	if (dirtgt)
+		glfs_h_close (dirtgt);
+	if (dleaf)
+		glfs_h_close (dleaf);
+
+	return;
+}
+
+void
+assimilatetime (struct timespec *ts, struct timespec ts_st,
+		struct timespec ts_ed)
+{
+	if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+		ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+		ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+	} else {
+		ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+		ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+	}
+
+	if (ts->tv_nsec > 1000000000) {
+		ts->tv_nsec = ts->tv_nsec - 1000000000;
+		ts->tv_sec += 1;
+	}
+
+	return;
+}
+
+#define MAX_FILES_CREATE 10
+#define MAXPATHNAME      512
+void
+test_h_performance (void)
+{
+	char               *my_dir = "perftest",
+	                   *full_dir_path="/testdir/perftest";
+	char               *my_file = "file_", my_file_name[MAXPATHNAME];
+	struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+	struct stat         sb, retsb;
+	int                 ret, valid, i;
+	struct glfs_fd     *fd;
+	struct timespec     c_ts = {0, 0}, c_ts_st, c_ts_ed;
+	struct timespec     o_ts = {0, 0}, o_ts_st, o_ts_ed;
+
+	printf("glfs_h_performance tests: In Progress\n");
+
+	/* Prepare tests */
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, NULL, strerror (errno));
+		printf ("glfs_h_performance tests: FAILED\n");
+		goto out;
+	}
+
+	dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
+	if (dir == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, parent, strerror (errno));
+		printf ("glfs_h_performance tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* create performance */
+	ret = clock_gettime (CLOCK_REALTIME, &o_ts_st);
+	if(ret != 0) {
+		fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+
+	for (i = 0; i < MAX_FILES_CREATE; i++) {
+		sprintf (my_file_name, "%s%d", my_file, i);
+
+		ret = clock_gettime (CLOCK_REALTIME, &c_ts_st);
+		if(ret != 0) {
+			fprintf (stderr, "clock_gettime: error %s\n",
+				 strerror (errno));
+			printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+			goto out;
+		}
+
+		leaf = glfs_h_lookupat (fs, dir, my_file_name, &sb);
+		if (leaf != NULL) {
+			fprintf (stderr, "glfs_h_lookup: exists %s\n",
+				 my_file_name);
+			printf ("glfs_h_performance tests: FAILED\n");
+			goto out;
+		}
+
+		leaf = glfs_h_creat (fs, dir, my_file_name, O_CREAT, 0644, &sb);
+		if (leaf == NULL) {
+			fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+				 my_file, dir, strerror (errno));
+			printf ("glfs_h_performance tests: FAILED\n");
+			goto out;
+		}
+
+		ret = clock_gettime (CLOCK_REALTIME, &c_ts_ed);
+		if(ret != 0) {
+			fprintf (stderr, "clock_gettime: error %s\n",
+				 strerror (errno));
+			printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+			goto out;
+		}
+
+		assimilatetime (&c_ts, c_ts_st, c_ts_ed);
+		glfs_h_close (leaf); leaf = NULL;
+	}
+
+	ret = clock_gettime (CLOCK_REALTIME, &o_ts_ed);
+	if(ret != 0) {
+		fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+
+	assimilatetime (&o_ts, o_ts_st, o_ts_ed);
+
+	printf ("Creation performance (handle based):\n\t# empty files:%d\n",
+		MAX_FILES_CREATE);
+	printf ("\tOverall time:\n\t\tSecs:%d\n\t\tnSecs:%d\n",
+		o_ts.tv_sec, o_ts.tv_nsec);
+	printf ("\tcreate call time time:\n\t\tSecs:%d\n\t\tnSecs:%d\n",
+		c_ts.tv_sec, c_ts.tv_nsec);
+
+	/* create using path */
+	c_ts.tv_sec = o_ts.tv_sec = 0;
+	c_ts.tv_nsec = o_ts.tv_nsec = 0;
+
+	sprintf (my_file_name, "%s1", full_dir_path);
+	ret = glfs_mkdir (fs, my_file_name, 0644);
+	if (ret != 0) {
+		fprintf (stderr, "glfs_mkdir: error creating %s: from (%p),%s\n",
+			 my_dir, parent, strerror (errno));
+		printf ("glfs_h_performance tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	ret = clock_gettime (CLOCK_REALTIME, &o_ts_st);
+	if(ret != 0) {
+		fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+
+	for (i = 0; i < MAX_FILES_CREATE; i++) {
+		sprintf (my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
+
+		ret = clock_gettime (CLOCK_REALTIME, &c_ts_st);
+		if(ret != 0) {
+			fprintf (stderr, "clock_gettime: error %s\n",
+				 strerror (errno));
+			printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+			goto out;
+		}
+
+		ret = glfs_stat (fs, my_file_name, &sb);
+		if (ret == 0) {
+			fprintf (stderr, "glfs_stat: exists %s\n",
+				 my_file_name);
+			printf ("glfs_h_performance tests: FAILED\n");
+			goto out;
+		}
+
+		fd = glfs_creat (fs, my_file_name, O_CREAT, 0644);
+		if (fd == NULL) {
+			fprintf (stderr, "glfs_creat: error creating %s: from (%p),%s\n",
+				 my_file, dir, strerror (errno));
+			printf ("glfs_h_performance tests: FAILED\n");
+			goto out;
+		}
+
+		ret = clock_gettime (CLOCK_REALTIME, &c_ts_ed);
+		if(ret != 0) {
+			fprintf (stderr, "clock_gettime: error %s\n",
+				 strerror (errno));
+			printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+			goto out;
+		}
+
+		assimilatetime (&c_ts, c_ts_st, c_ts_ed);
+		glfs_close (fd);
+	}
+
+	ret = clock_gettime (CLOCK_REALTIME, &o_ts_ed);
+	if(ret != 0) {
+		fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
+		printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
+		goto out;
+	}
+
+	assimilatetime (&o_ts, o_ts_st, o_ts_ed);
+
+	printf ("Creation performance (path based):\n\t# empty files:%d\n",
+		MAX_FILES_CREATE);
+	printf ("\tOverall time:\n\t\tSecs:%d\n\t\tnSecs:%d\n",
+		o_ts.tv_sec, o_ts.tv_nsec);
+	printf ("\tcreate call time time:\n\t\tSecs:%d\n\t\tnSecs:%d\n",
+		c_ts.tv_sec, c_ts.tv_nsec);
+out:
+	return;
+}
+
+int
+test_handleops (int argc, char *argv[])
+{
+	int                 ret = 0;
+	glfs_fd_t          *fd = NULL;
+	struct stat         sb = {0, };
+	struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+	                   *tmp = NULL;
+	char                readbuf[32], writebuf[32];
+	unsigned char       leaf_handle[GFAPI_HANDLE_LENGTH];
+
+	char *full_leaf_name = "/testdir/testfile.txt",
+	     *leaf_name = "testfile.txt",
+	     *relative_leaf_name = "testdir/testfile.txt";
+	char *leaf_name1 = "testfile1.txt";
+	char *full_newparent_name = "/testdir/dir1",
+	     *newparent_name = "dir1";
+	char *full_newnod_name = "/testdir/nod1",
+	     *newnod_name = "nod1";
+
+	/* Initialize test area */
+	ret = glfs_mkdir (fs, full_parent_name, 0644);
+	if (ret != 0 && errno != EEXIST) {
+		fprintf (stderr, "%s: (%p) %s\n", full_parent_name, fd,
+			strerror (errno));
+		printf ("Test initialization failed on volume %s\n", argv[1]);
+		goto out;
+	}
+	else if (ret != 0) {
+		printf ("Found test directory %s to be existing\n",
+			full_parent_name);
+		printf ("Cleanup test directory and restart tests\n");
+		goto out;
+	}
+
+	fd = glfs_creat (fs, full_leaf_name, O_CREAT, 0644);
+	if (fd == NULL) {
+		fprintf (stderr, "%s: (%p) %s\n", full_leaf_name, fd,
+			strerror (errno));
+		printf ("Test initialization failed on volume %s\n", argv[1]);
+		goto out;
+	}
+	glfs_close (fd);
+
+	printf ("Initialized the test area, within volume %s\n", argv[1]);
+
+	/* Handle based APIs test area */
+
+	/* glfs_lookupat test */
+	printf ("glfs_h_lookupat tests: In Progress\n");
+	/* start at root of the volume */
+	root = glfs_h_lookupat (fs, NULL, "/", &sb);
+	if (root == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 "/", NULL, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* lookup a parent within root */
+	parent = glfs_h_lookupat (fs, root, parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 parent_name, root, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* lookup a leaf/child within the parent */
+	leaf = glfs_h_lookupat (fs, parent, leaf_name, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 leaf_name, parent, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* reset */
+	glfs_h_close (root); root = NULL;
+	glfs_h_close (leaf); leaf = NULL;
+	glfs_h_close (parent); parent = NULL;
+
+	/* check absolute paths */
+	root = glfs_h_lookupat (fs, NULL, "/", &sb);
+	if (root == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 "/", NULL, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, root, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_lookupat (fs, NULL, full_leaf_name, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_leaf_name, parent, strerror (errno));
+		printf ("glfs_h_lookupat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* reset */
+	glfs_h_close (leaf); leaf = NULL;
+
+	/* check multiple component paths */
+	leaf = glfs_h_lookupat (fs, root, relative_leaf_name, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 relative_leaf_name, parent, strerror (errno));
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* reset */
+	glfs_h_close (root); root = NULL;
+	glfs_h_close (parent); parent = NULL;
+
+	/* check symlinks in path */
+
+	/* TODO: -ve test cases */
+	/* parent invalid
+	* path invalid
+	* path does not exist after some components
+	* no parent, but relative path
+	* parent and full path? -ve?
+	*/
+
+	printf ("glfs_h_lookupat tests: PASSED\n");
+
+	/* glfs_openat test */
+	printf ("glfs_h_open tests: In Progress\n");
+	fd = glfs_h_open (fs, leaf, O_RDWR);
+	if (fd == NULL) {
+		fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
+			 full_leaf_name, strerror (errno));
+		printf ("glfs_h_open tests: FAILED\n");
+		goto out;
+	}
+
+	/* test read/write based on fd */
+	memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+	ret = glfs_write (fd, writebuf, 32, 0);
+
+	glfs_lseek (fd, 0, SEEK_SET);
+
+	ret = glfs_read (fd, readbuf, 32, 0);
+	if (memcmp (readbuf, writebuf, 32)) {
+		printf ("Failed to read what I wrote: %s %s\n", readbuf,
+			writebuf);
+		glfs_close (fd);
+		printf ("glfs_h_open tests: FAILED\n");
+		goto out;
+	}
+
+	glfs_h_close (leaf); leaf = NULL;
+	glfs_close (fd);
+
+	printf ("glfs_h_open tests: PASSED\n");
+
+	/* Create tests */
+	printf ("glfs_h_creat tests: In Progress\n");
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, root, strerror (errno));
+		printf ("glfs_h_creat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_creat (fs, parent, leaf_name1, O_CREAT, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+			 leaf_name1, parent, strerror (errno));
+		printf ("glfs_h_creat tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	glfs_h_close (leaf); leaf = NULL;
+
+	leaf = glfs_h_creat (fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644,
+			    &sb);
+	if (leaf != NULL || errno != EEXIST) {
+		fprintf (stderr, "glfs_h_creat: existing file, leaf = (%p), errno = %s\n",
+			leaf, strerror (errno));
+		printf ("glfs_h_creat tests: FAILED\n");
+		if (leaf != NULL) {
+			glfs_h_close (leaf); leaf = NULL;
+		}
+	}
+
+	tmp = glfs_h_creat (fs, root, parent_name, O_CREAT, 0644, &sb);
+	if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
+		fprintf (stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
+			leaf, strerror (errno));
+		printf ("glfs_h_creat tests: FAILED\n");
+		if (tmp != NULL) {
+			glfs_h_close (tmp); tmp = NULL;
+		}
+	}
+
+	/* TODO: Other combinations and -ve cases as applicable */
+	printf ("glfs_h_creat tests: PASSED\n");
+
+	/* extract handle and create from handle test */
+	printf ("glfs_h_extract_handle and glfs_h_create_from_handle tests: In Progress\n");
+	/* TODO: Change the lookup to creat below for a GIFD recovery falure,
+	 * that needs to be fixed */
+	leaf = glfs_h_lookupat (fs, parent, leaf_name1, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 leaf_name1, parent, strerror (errno));
+		printf ("glfs_h_extract_handle tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	ret = glfs_h_extract_handle (leaf, leaf_handle,
+					     GFAPI_HANDLE_LENGTH);
+	if (ret < 0) {
+		fprintf (stderr, "glfs_h_extract_handle: error extracting handle of %s: %s\n",
+			 full_leaf_name, strerror (errno));
+		printf ("glfs_h_extract_handle tests: FAILED\n");
+		goto out;
+	}
+	peek_handle (leaf_handle);
+
+	glfs_h_close (leaf); leaf = NULL;
+
+	leaf = glfs_h_create_from_handle (fs, leaf_handle, GFAPI_HANDLE_LENGTH,
+					  &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
+			 leaf_name1, leaf_handle, strerror (errno));
+		printf ("glfs_h_create_from_handle tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	fd = glfs_h_open (fs, leaf, O_RDWR);
+	if (fd == NULL) {
+		fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
+			 full_leaf_name, strerror (errno));
+		printf ("glfs_h_create_from_handle tests: FAILED\n");
+		goto out;
+	}
+
+	/* test read/write based on fd */
+	memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+	ret = glfs_write (fd, writebuf, 32, 0);
+
+	glfs_lseek (fd, 0, SEEK_SET);
+
+	ret = glfs_read (fd, readbuf, 32, 0);
+	if (memcmp (readbuf, writebuf, 32)) {
+		printf ("Failed to read what I wrote: %s %s\n", writebuf,
+			writebuf);
+		printf ("glfs_h_create_from_handle tests: FAILED\n");
+		glfs_close (fd);
+		goto out;
+	}
+
+	glfs_close (fd);
+	glfs_h_close (leaf); leaf = NULL;
+	glfs_h_close (parent); parent = NULL;
+
+	printf ("glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
+
+	/* Mkdir tests */
+	printf ("glfs_h_mkdir tests: In Progress\n");
+
+	ret = glfs_rmdir (fs, full_newparent_name);
+	if (ret && errno != ENOENT) {
+		fprintf (stderr, "glfs_rmdir: Failed for %s: %s\n",
+			 full_newparent_name, strerror (errno));
+		printf ("glfs_h_mkdir tests: FAILED\n");
+		goto out;
+	}
+
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, root, strerror (errno));
+		printf ("glfs_h_mkdir tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_mkdir (fs, parent, newparent_name, 0644, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+			 newparent_name, parent, strerror (errno));
+		printf ("glfs_h_mkdir tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	glfs_h_close (leaf); leaf = NULL;
+
+	leaf = glfs_h_mkdir (fs, parent, newparent_name, 0644, &sb);
+	if (leaf != NULL || errno != EEXIST) {
+		fprintf (stderr, "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
+			 leaf, strerror (errno));
+		printf ("glfs_h_mkdir tests: FAILED\n");
+		if (leaf != NULL) {
+			glfs_h_close (leaf); leaf = NULL;
+		}
+	}
+
+	glfs_h_close (parent); parent = NULL;
+
+	printf ("glfs_h_mkdir tests: PASSED\n");
+
+	/* Mknod tests */
+	printf ("glfs_h_mknod tests: In Progress\n");
+	ret = glfs_unlink (fs, full_newnod_name);
+	if (ret && errno != ENOENT) {
+		fprintf (stderr, "glfs_unlink: Failed for %s: %s\n",
+			 full_newnod_name, strerror (errno));
+		printf ("glfs_h_mknod tests: FAILED\n");
+		goto out;
+	}
+
+	parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb);
+	if (parent == NULL) {
+		fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+			 full_parent_name, root, strerror (errno));
+		printf ("glfs_h_mknod tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	leaf = glfs_h_mknod (fs, parent, newnod_name, S_IFIFO, 0, &sb);
+	if (leaf == NULL) {
+		fprintf (stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+			 newnod_name, parent, strerror (errno));
+		printf ("glfs_h_mknod tests: FAILED\n");
+		goto out;
+	}
+	peek_stat (&sb);
+
+	/* TODO: creat op on a FIFO node hangs, need to check and fix
+	tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
+	if (tmp != NULL || errno != EINVAL) {
+		fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno = %s\n",
+			tmp, strerror (errno));
+		printf ("glfs_h_creat/mknod tests: FAILED\n");
+		if (tmp != NULL) {
+			glfs_h_close(tmp); tmp = NULL;
+		}
+	} */
+
+	glfs_h_close (leaf); leaf = NULL;
+
+	leaf = glfs_h_mknod (fs, parent, newnod_name, 0644, 0, &sb);
+	if (leaf != NULL || errno != EEXIST) {
+		fprintf (stderr, "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n",
+			 leaf, strerror (errno));
+		printf ("glfs_h_mknod tests: FAILED\n");
+		if (leaf != NULL) {
+			glfs_h_close (leaf); leaf = NULL;
+		}
+	}
+
+	glfs_h_close (parent); parent = NULL;
+
+	printf ("glfs_h_mknod tests: PASSED\n");
+
+	/* unlink tests */
+	test_h_unlink ();
+
+	/* TODO: opendir tests */
+
+	/* getattr tests */
+	test_h_getsetattrs ();
+
+	/* TODO: setattr tests */
+
+	/* truncate tests */
+	test_h_truncate();
+
+	/* link tests */
+	test_h_links ();
+
+	/* rename tests */
+	test_h_rename ();
+
+	/* performance tests */
+	test_h_performance ();
+
+	/* END: New APIs test area */
+
+out:
+	/* Cleanup glfs handles */
+	if (root)
+		glfs_h_close (root);
+	if (parent)
+		glfs_h_close (parent);
+	if (leaf)
+		glfs_h_close (leaf);
+
+	return ret;
+}
 
 int
 main (int argc, char *argv[])
 {
-	glfs_t    *fs = NULL;
 	glfs_t    *fs2 = NULL;
 	int        ret = 0;
 	glfs_fd_t *fd = NULL;
@@ -148,7 +1496,12 @@ main (int argc, char *argv[])
 
 	char      *filename = "/filename2";
 
-	fs = glfs_new ("fsync");
+	if (argc != 3) {
+		printf ("Expect following args\n\t%s <volname> <hostname>\n", argv[0]);
+		return -1;
+	}
+
+	fs = glfs_new (argv[1]);
 	if (!fs) {
 		fprintf (stderr, "glfs_new: returned NULL\n");
 		return 1;
@@ -156,7 +1509,7 @@ main (int argc, char *argv[])
 
 //	ret = glfs_set_volfile (fs, "/tmp/posix.vol");
 
-	ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
+	ret = glfs_set_volfile_server (fs, "tcp", argv[2], 24007);
 
 //	ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
 
@@ -168,7 +1521,7 @@ main (int argc, char *argv[])
 
 	sleep (2);
 
-	fs2 = glfs_new ("fsync");
+	fs2 = glfs_new (argv[1]);
 	if (!fs2) {
 		fprintf (stderr, "glfs_new: returned NULL\n");
 		return 1;
@@ -177,7 +1530,7 @@ main (int argc, char *argv[])
 
 //	ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
 
-	ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007);
+	ret = glfs_set_volfile_server (fs2, "tcp", argv[2], 24007);
 
 	ret = glfs_set_logging (fs2, "/dev/stderr", 7);
 
@@ -238,6 +1591,7 @@ main (int argc, char *argv[])
 
 	test_chdir (fs);
 
+	test_handleops (argc, argv);
 	// done
 
 	glfs_fini (fs);