api: versioned symbols in libgfapi.so for compatibility

Use versioned symbols to keep libgfapi at libgfapi.so.0.0.0

Some nits uncovered:

+ there are a couple functions declared that do not have an
  associated definition, e.g. glfs_truncate(), glfs_caller_specific_init()

+ there are seven private/internal functions used by heal/src/glfsheal
  and the gfapi master xlator (glfs-master.c): glfs_loc_touchup(),
  glfs_active_subvol(), and glfs_subvol_done(), glfs_init_done(),
  glfs_resolve_at(), glfs_free_from_ctx(), and glfs_new_from_ctx();
  which are not declared in glfs.h;

+ for this initial pass at versioned symbols, we use the earliest version
  of all public symbols, i.e. those for which there are declarations in
  glfs.h or glfs-handles.h.
  Further investigation as we do backports to 3.6, 3.4, and 3.4
  will be required to determine if older implementations need to
  be preserved (forward ported) and their associated alias(es) and
  symbol version(s) defined.

FWIW, we should consider linking all of our libraries with a map, it'll
result in a cleaner ABI. Perhaps something for an intern to do or a
Google Summer of Code project.

Change-Id: I499456807a5cd26acb39843216ece4276f8e9b84
BUG: 1160709
Signed-off-by: Kaleb S. KEITHLEY <kkeithle@redhat.com>
Reviewed-on: http://review.gluster.org/9036
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Niels de Vos <ndevos@redhat.com>
Tested-by: Niels de Vos <ndevos@redhat.com>
Reviewed-by: Vijay Bellur <vbellur@redhat.com>

1 files changed, 396 insertions, 218 deletions

diff --git a/api/src/glfs-fops.c b/api/src/glfs-fops.c
index 66a3df2b2d1..b93a077fcdf 100644
--- a/api/src/glfs-fops.c
+++ b/api/src/glfs-fops.c
@@ -68,7 +68,7 @@ glfs_loc_unlink (loc_t *loc)
 
 
 struct glfs_fd *
-glfs_open (struct glfs *fs, const char *path, int flags)
+pub_glfs_open (struct glfs *fs, const char *path, int flags)
 {
 	int              ret = -1;
 	struct glfs_fd  *glfd = NULL;
@@ -79,7 +79,7 @@ glfs_open (struct glfs *fs, const char *path, int flags)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -141,14 +141,16 @@ out:
 		glfs_fd_bind (glfd);
 	}
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return glfd;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_open, 3.4.0);
+
 
 int
-glfs_close (struct glfs_fd *glfd)
+pub_glfs_close (struct glfs_fd *glfd)
 {
 	xlator_t  *subvol = NULL;
 	int        ret = -1;
@@ -157,7 +159,7 @@ glfs_close (struct glfs_fd *glfd)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
         if (!subvol) {
                 ret = -1;
                 errno = EIO;
@@ -180,14 +182,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_close, 3.4.0);
+
 
 int
-glfs_lstat (struct glfs *fs, const char *path, struct stat *stat)
+pub_glfs_lstat (struct glfs *fs, const char *path, struct stat *stat)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -197,7 +201,7 @@ glfs_lstat (struct glfs *fs, const char *path, struct stat *stat)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -213,14 +217,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lstat, 3.4.0);
+
 
 int
-glfs_stat (struct glfs *fs, const char *path, struct stat *stat)
+pub_glfs_stat (struct glfs *fs, const char *path, struct stat *stat)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -230,7 +236,7 @@ glfs_stat (struct glfs *fs, const char *path, struct stat *stat)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -246,14 +252,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_stat, 3.4.0);
+
 
 int
-glfs_fstat (struct glfs_fd *glfd, struct stat *stat)
+pub_glfs_fstat (struct glfs_fd *glfd, struct stat *stat)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -262,7 +270,7 @@ glfs_fstat (struct glfs_fd *glfd, struct stat *stat)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -285,14 +293,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0);
+
 
 struct glfs_fd *
-glfs_creat (struct glfs *fs, const char *path, int flags, mode_t mode)
+pub_glfs_creat (struct glfs *fs, const char *path, int flags, mode_t mode)
 {
 	int              ret = -1;
 	struct glfs_fd  *glfd = NULL;
@@ -305,7 +315,7 @@ glfs_creat (struct glfs *fs, const char *path, int flags, mode_t mode)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -423,14 +433,16 @@ out:
 		glfs_fd_bind (glfd);
 	}
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return glfd;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_creat, 3.4.0);
+
 
 off_t
-glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence)
+pub_glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence)
 {
 	struct stat sb = {0, };
 	int         ret = -1;
@@ -445,7 +457,7 @@ glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence)
 		glfd->offset += offset;
 		break;
 	case SEEK_END:
-		ret = glfs_fstat (glfd, &sb);
+		ret = pub_glfs_fstat (glfd, &sb);
 		if (ret) {
 			/* seek cannot fail :O */
 			break;
@@ -457,12 +469,12 @@ glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence)
 	return glfd->offset;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lseek, 3.4.0);
 
-//////////////
 
 ssize_t
-glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-	     off_t offset, int flags)
+pub_glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                 off_t offset, int flags)
 {
 	xlator_t       *subvol = NULL;
 	ssize_t         ret = -1;
@@ -474,7 +486,7 @@ glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -509,14 +521,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv, 3.4.0);
+
 
 ssize_t
-glfs_read (struct glfs_fd *glfd, void *buf, size_t count, int flags)
+pub_glfs_read (struct glfs_fd *glfd, void *buf, size_t count, int flags)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -524,15 +538,17 @@ glfs_read (struct glfs_fd *glfd, void *buf, size_t count, int flags)
 	iov.iov_base = buf;
 	iov.iov_len = count;
 
-	ret = glfs_preadv (glfd, &iov, 1, glfd->offset, flags);
+	ret = pub_glfs_preadv (glfd, &iov, 1, glfd->offset, flags);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read, 3.4.0);
+
 
 ssize_t
-glfs_pread (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
-	    int flags)
+pub_glfs_pread (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
+                int flags)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -540,23 +556,27 @@ glfs_pread (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
 	iov.iov_base = buf;
 	iov.iov_len = count;
 
-	ret = glfs_preadv (glfd, &iov, 1, offset, flags);
+	ret = pub_glfs_preadv (glfd, &iov, 1, offset, flags);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread, 3.4.0);
+
 
 ssize_t
-glfs_readv (struct glfs_fd *glfd, const struct iovec *iov, int count,
-	    int flags)
+pub_glfs_readv (struct glfs_fd *glfd, const struct iovec *iov, int count,
+                int flags)
 {
 	ssize_t      ret = 0;
 
-	ret = glfs_preadv (glfd, iov, count, glfd->offset, flags);
+	ret = pub_glfs_preadv (glfd, iov, count, glfd->offset, flags);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv, 3.4.0);
+
 
 struct glfs_io {
 	struct glfs_fd      *glfd;
@@ -583,6 +603,23 @@ glfs_io_async_cbk (int ret, call_frame_t *frame, void *data)
 	return 0;
 }
 
+ssize_t
+pub_glfs_pwritev (struct glfs_fd *, const struct iovec *, int, off_t, int);
+
+int
+pub_glfs_ftruncate (struct glfs_fd *, off_t);
+
+int
+pub_glfs_fdatasync (struct glfs_fd *);
+
+int
+pub_glfs_fsync (struct glfs_fd *glfd);
+
+int
+pub_glfs_discard (struct glfs_fd *, off_t, size_t);
+
+int
+pub_glfs_zerofill (struct glfs_fd *, off_t, off_t);
 
 static int
 glfs_io_async_task (void *data)
@@ -592,23 +629,23 @@ glfs_io_async_task (void *data)
 
 	switch (gio->op) {
 	case GF_FOP_WRITE:
-		ret = glfs_pwritev (gio->glfd, gio->iov, gio->count,
+		ret = pub_glfs_pwritev (gio->glfd, gio->iov, gio->count,
 				    gio->offset, gio->flags);
 		break;
 	case GF_FOP_FTRUNCATE:
-		ret = glfs_ftruncate (gio->glfd, gio->offset);
+		ret = pub_glfs_ftruncate (gio->glfd, gio->offset);
 		break;
 	case GF_FOP_FSYNC:
 		if (gio->flags)
-			ret = glfs_fdatasync (gio->glfd);
+			ret = pub_glfs_fdatasync (gio->glfd);
 		else
-			ret = glfs_fsync (gio->glfd);
+			ret = pub_glfs_fsync (gio->glfd);
 		break;
 	case GF_FOP_DISCARD:
-		ret = glfs_discard (gio->glfd, gio->offset, gio->count);
+		ret = pub_glfs_discard (gio->glfd, gio->offset, gio->count);
 		break;
         case GF_FOP_ZEROFILL:
-                ret = glfs_zerofill(gio->glfd, gio->offset, gio->count);
+                ret = pub_glfs_zerofill(gio->glfd, gio->offset, gio->count);
                 break;
 	}
 
@@ -647,15 +684,16 @@ out:
 	GF_FREE (gio->iov);
 	GF_FREE (gio);
 	STACK_DESTROY (frame->root);
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return 0;
 }
 
 
 int
-glfs_preadv_async (struct glfs_fd *glfd, const struct iovec *iovec, int count,
-		   off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_preadv_async (struct glfs_fd *glfd, const struct iovec *iovec,
+                       int count, off_t offset, int flags, glfs_io_cbk fn,
+                       void *data)
 {
 	struct glfs_io *gio = NULL;
 	int             ret = 0;
@@ -666,7 +704,7 @@ glfs_preadv_async (struct glfs_fd *glfd, const struct iovec *iovec, int count,
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -726,7 +764,7 @@ out:
                 if (frame) {
                         STACK_DESTROY (frame->root);
                 }
-		glfs_subvol_done (fs, subvol);
+		priv_glfs_subvol_done (fs, subvol);
 	}
 
 	if (fd)
@@ -735,10 +773,12 @@ out:
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, 3.4.0);
+
 
 int
-glfs_read_async (struct glfs_fd *glfd, void *buf, size_t count, int flags,
-		 glfs_io_cbk fn, void *data)
+pub_glfs_read_async (struct glfs_fd *glfd, void *buf, size_t count, int flags,
+                     glfs_io_cbk fn, void *data)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -746,15 +786,17 @@ glfs_read_async (struct glfs_fd *glfd, void *buf, size_t count, int flags,
 	iov.iov_base = buf;
 	iov.iov_len = count;
 
-	ret = glfs_preadv_async (glfd, &iov, 1, glfd->offset, flags, fn, data);
+	ret = pub_glfs_preadv_async (glfd, &iov, 1, glfd->offset, flags, fn, data);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read_async, 3.4.0);
+
 
 int
-glfs_pread_async (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
-		  int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pread_async (struct glfs_fd *glfd, void *buf, size_t count,
+                      off_t offset, int flags, glfs_io_cbk fn, void *data)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -762,28 +804,31 @@ glfs_pread_async (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
 	iov.iov_base = buf;
 	iov.iov_len = count;
 
-	ret = glfs_preadv_async (glfd, &iov, 1, offset, flags, fn, data);
+	ret = pub_glfs_preadv_async (glfd, &iov, 1, offset, flags, fn, data);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread_async, 3.4.0);
+
 
 int
-glfs_readv_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
-		  int flags, glfs_io_cbk fn, void *data)
+pub_glfs_readv_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
+                      int flags, glfs_io_cbk fn, void *data)
 {
 	ssize_t      ret = 0;
 
-	ret = glfs_preadv_async (glfd, iov, count, glfd->offset, flags,
-				 fn, data);
+	ret = pub_glfs_preadv_async (glfd, iov, count, glfd->offset, flags,
+				  fn, data);
 	return ret;
 }
 
-///// writev /////
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv_async, 3.4.0);
+
 
 ssize_t
-glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-	      off_t offset, int flags)
+pub_glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                  off_t offset, int flags)
 {
 	xlator_t       *subvol = NULL;
 	int             ret = -1;
@@ -795,7 +840,7 @@ glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -855,14 +900,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0);
+
 
 ssize_t
-glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, int flags)
+pub_glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, int flags)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -870,28 +917,31 @@ glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, int flags)
 	iov.iov_base = (void *) buf;
 	iov.iov_len = count;
 
-	ret = glfs_pwritev (glfd, &iov, 1, glfd->offset, flags);
+	ret = pub_glfs_pwritev (glfd, &iov, 1, glfd->offset, flags);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write, 3.4.0);
 
 
 ssize_t
-glfs_writev (struct glfs_fd *glfd, const struct iovec *iov, int count,
-	     int flags)
+pub_glfs_writev (struct glfs_fd *glfd, const struct iovec *iov, int count,
+                 int flags)
 {
 	ssize_t      ret = 0;
 
-	ret = glfs_pwritev (glfd, iov, count, glfd->offset, flags);
+	ret = pub_glfs_pwritev (glfd, iov, count, glfd->offset, flags);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev, 3.4.0);
+
 
 ssize_t
-glfs_pwrite (struct glfs_fd *glfd, const void *buf, size_t count, off_t offset,
-	     int flags)
+pub_glfs_pwrite (struct glfs_fd *glfd, const void *buf, size_t count,
+                 off_t offset, int flags)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -899,15 +949,20 @@ glfs_pwrite (struct glfs_fd *glfd, const void *buf, size_t count, off_t offset,
 	iov.iov_base = (void *) buf;
 	iov.iov_len = count;
 
-	ret = glfs_pwritev (glfd, &iov, 1, offset, flags);
+	ret = pub_glfs_pwritev (glfd, &iov, 1, offset, flags);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite, 3.4.0);
+
+
+extern glfs_t *pub_glfs_from_glfd (glfs_fd_t *);
 
 int
-glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec, int count,
-		    off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec,
+                        int count, off_t offset, int flags, glfs_io_cbk fn,
+                        void *data)
 {
 	struct glfs_io *gio = NULL;
 	int             ret = 0;
@@ -933,7 +988,7 @@ glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec, int count,
 	gio->fn     = fn;
 	gio->data   = data;
 
-	ret = synctask_new (glfs_from_glfd (glfd)->ctx->env,
+	ret = synctask_new (pub_glfs_from_glfd (glfd)->ctx->env,
 			    glfs_io_async_task, glfs_io_async_cbk,
 			    NULL, gio);
 
@@ -945,10 +1000,12 @@ glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec, int count,
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, 3.4.0);
+
 
 int
-glfs_write_async (struct glfs_fd *glfd, const void *buf, size_t count, int flags,
-		  glfs_io_cbk fn, void *data)
+pub_glfs_write_async (struct glfs_fd *glfd, const void *buf, size_t count,
+                      int flags, glfs_io_cbk fn, void *data)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -956,15 +1013,17 @@ glfs_write_async (struct glfs_fd *glfd, const void *buf, size_t count, int flags
 	iov.iov_base = (void *) buf;
 	iov.iov_len = count;
 
-	ret = glfs_pwritev_async (glfd, &iov, 1, glfd->offset, flags, fn, data);
+	ret = pub_glfs_pwritev_async (glfd, &iov, 1, glfd->offset, flags, fn, data);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write_async, 3.4.0);
+
 
 int
-glfs_pwrite_async (struct glfs_fd *glfd, const void *buf, int count,
-		   off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pwrite_async (struct glfs_fd *glfd, const void *buf, int count,
+                       off_t offset, int flags, glfs_io_cbk fn, void *data)
 {
 	struct iovec iov = {0, };
 	ssize_t      ret = 0;
@@ -972,26 +1031,30 @@ glfs_pwrite_async (struct glfs_fd *glfd, const void *buf, int count,
 	iov.iov_base = (void *) buf;
 	iov.iov_len = count;
 
-	ret = glfs_pwritev_async (glfd, &iov, 1, offset, flags, fn, data);
+	ret = pub_glfs_pwritev_async (glfd, &iov, 1, offset, flags, fn, data);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_async, 3.4.0);
+
 
 int
-glfs_writev_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
-		   int flags, glfs_io_cbk fn, void *data)
+pub_glfs_writev_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
+                       int flags, glfs_io_cbk fn, void *data)
 {
 	ssize_t      ret = 0;
 
-	ret = glfs_pwritev_async (glfd, iov, count, glfd->offset, flags,
-				  fn, data);
+	ret = pub_glfs_pwritev_async (glfd, iov, count, glfd->offset, flags,
+				   fn, data);
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev_async, 3.4.0);
+
 
 int
-glfs_fsync (struct glfs_fd *glfd)
+pub_glfs_fsync (struct glfs_fd *glfd)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -999,7 +1062,7 @@ glfs_fsync (struct glfs_fd *glfd)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1019,11 +1082,13 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, 3.4.0);
+
 
 static int
 glfs_fsync_async_common (struct glfs_fd *glfd, glfs_io_cbk fn, void *data,
@@ -1044,7 +1109,7 @@ glfs_fsync_async_common (struct glfs_fd *glfd, glfs_io_cbk fn, void *data,
 	gio->fn     = fn;
 	gio->data   = data;
 
-	ret = synctask_new (glfs_from_glfd (glfd)->ctx->env,
+	ret = synctask_new (pub_glfs_from_glfd (glfd)->ctx->env,
 			    glfs_io_async_task, glfs_io_async_cbk,
 			    NULL, gio);
 
@@ -1059,14 +1124,16 @@ glfs_fsync_async_common (struct glfs_fd *glfd, glfs_io_cbk fn, void *data,
 
 
 int
-glfs_fsync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fsync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
 {
 	return glfs_fsync_async_common (glfd, fn, data, 0);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, 3.4.0);
+
 
 int
-glfs_fdatasync (struct glfs_fd *glfd)
+pub_glfs_fdatasync (struct glfs_fd *glfd)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1074,7 +1141,7 @@ glfs_fdatasync (struct glfs_fd *glfd)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1094,21 +1161,25 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, 3.4.0);
+
 
 int
-glfs_fdatasync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fdatasync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
 {
 	return glfs_fsync_async_common (glfd, fn, data, 1);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, 3.4.0);
+
 
 int
-glfs_ftruncate (struct glfs_fd *glfd, off_t offset)
+pub_glfs_ftruncate (struct glfs_fd *glfd, off_t offset)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1116,7 +1187,7 @@ glfs_ftruncate (struct glfs_fd *glfd, off_t offset)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1136,15 +1207,17 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, 3.4.0);
+
 
 int
-glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset,
-		      glfs_io_cbk fn, void *data)
+pub_glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset, glfs_io_cbk fn,
+                          void *data)
 {
 	struct glfs_io *gio = NULL;
 	int             ret = 0;
@@ -1161,7 +1234,7 @@ glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset,
 	gio->fn     = fn;
 	gio->data   = data;
 
-	ret = synctask_new (glfs_from_glfd (glfd)->ctx->env,
+	ret = synctask_new (pub_glfs_from_glfd (glfd)->ctx->env,
 			    glfs_io_async_task, glfs_io_async_cbk,
 			    NULL, gio);
 
@@ -1173,9 +1246,11 @@ glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset,
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate_async, 3.4.0);
+
 
 int
-glfs_access (struct glfs *fs, const char *path, int mode)
+pub_glfs_access (struct glfs *fs, const char *path, int mode)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1185,7 +1260,7 @@ glfs_access (struct glfs *fs, const char *path, int mode)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1206,14 +1281,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_access, 3.4.0);
+
 
 int
-glfs_symlink (struct glfs *fs, const char *data, const char *path)
+pub_glfs_symlink (struct glfs *fs, const char *data, const char *path)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1225,7 +1302,7 @@ glfs_symlink (struct glfs *fs, const char *data, const char *path)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1288,14 +1365,16 @@ out:
 	if (xattr_req)
 		dict_unref (xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_symlink, 3.4.0);
+
 
 int
-glfs_readlink (struct glfs *fs, const char *path, char *buf, size_t bufsiz)
+pub_glfs_readlink (struct glfs *fs, const char *path, char *buf, size_t bufsiz)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1306,7 +1385,7 @@ glfs_readlink (struct glfs *fs, const char *path, char *buf, size_t bufsiz)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1337,14 +1416,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readlink, 3.4.0);
+
 
 int
-glfs_mknod (struct glfs *fs, const char *path, mode_t mode, dev_t dev)
+pub_glfs_mknod (struct glfs *fs, const char *path, mode_t mode, dev_t dev)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1356,7 +1437,7 @@ glfs_mknod (struct glfs *fs, const char *path, mode_t mode, dev_t dev)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1419,14 +1500,16 @@ out:
 	if (xattr_req)
 		dict_unref (xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mknod, 3.4.0);
+
 
 int
-glfs_mkdir (struct glfs *fs, const char *path, mode_t mode)
+pub_glfs_mkdir (struct glfs *fs, const char *path, mode_t mode)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1438,7 +1521,7 @@ glfs_mkdir (struct glfs *fs, const char *path, mode_t mode)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1501,14 +1584,16 @@ out:
 	if (xattr_req)
 		dict_unref (xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mkdir, 3.4.0);
+
 
 int
-glfs_unlink (struct glfs *fs, const char *path)
+pub_glfs_unlink (struct glfs *fs, const char *path)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1518,7 +1603,7 @@ glfs_unlink (struct glfs *fs, const char *path)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1548,14 +1633,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unlink, 3.4.0);
+
 
 int
-glfs_rmdir (struct glfs *fs, const char *path)
+pub_glfs_rmdir (struct glfs *fs, const char *path)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1565,7 +1652,7 @@ glfs_rmdir (struct glfs *fs, const char *path)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1595,14 +1682,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rmdir, 3.4.0);
+
 
 int
-glfs_rename (struct glfs *fs, const char *oldpath, const char *newpath)
+pub_glfs_rename (struct glfs *fs, const char *oldpath, const char *newpath)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1614,7 +1703,7 @@ glfs_rename (struct glfs *fs, const char *oldpath, const char *newpath)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1669,14 +1758,16 @@ out:
 	loc_wipe (&oldloc);
 	loc_wipe (&newloc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rename, 3.4.0);
+
 
 int
-glfs_link (struct glfs *fs, const char *oldpath, const char *newpath)
+pub_glfs_link (struct glfs *fs, const char *oldpath, const char *newpath)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -1688,7 +1779,7 @@ glfs_link (struct glfs *fs, const char *oldpath, const char *newpath)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1743,14 +1834,16 @@ out:
 	loc_wipe (&oldloc);
 	loc_wipe (&newloc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_link, 3.4.0);
+
 
 struct glfs_fd *
-glfs_opendir (struct glfs *fs, const char *path)
+pub_glfs_opendir (struct glfs *fs, const char *path)
 {
 	int              ret = -1;
 	struct glfs_fd  *glfd = NULL;
@@ -1761,7 +1854,7 @@ glfs_opendir (struct glfs *fs, const char *path)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -1817,14 +1910,16 @@ out:
 		glfs_fd_bind (glfd);
 	}
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return glfd;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_opendir, 3.4.0);
+
 
 int
-glfs_closedir (struct glfs_fd *glfd)
+pub_glfs_closedir (struct glfs_fd *glfd)
 {
 	__glfs_entry_fd (glfd);
 
@@ -1835,16 +1930,20 @@ glfs_closedir (struct glfs_fd *glfd)
 	return 0;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_closedir, 3.4.0);
+
 
 long
-glfs_telldir (struct glfs_fd *fd)
+pub_glfs_telldir (struct glfs_fd *fd)
 {
 	return fd->offset;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_telldir, 3.4.0);
+
 
 void
-glfs_seekdir (struct glfs_fd *fd, long offset)
+pub_glfs_seekdir (struct glfs_fd *fd, long offset)
 {
 	gf_dirent_t *entry = NULL;
 	gf_dirent_t *tmp = NULL;
@@ -1870,9 +1969,12 @@ glfs_seekdir (struct glfs_fd *fd, long offset)
 	*/
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_seekdir, 3.4.0);
+
+
 int
-glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len,
-		      glfs_io_cbk fn, void *data)
+pub_glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len,
+                        glfs_io_cbk fn, void *data)
 {
 	struct glfs_io *gio = NULL;
 	int             ret = 0;
@@ -1890,7 +1992,7 @@ glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len,
 	gio->fn     = fn;
 	gio->data   = data;
 
-	ret = synctask_new (glfs_from_glfd (glfd)->ctx->env,
+	ret = synctask_new (pub_glfs_from_glfd (glfd)->ctx->env,
 			    glfs_io_async_task, glfs_io_async_cbk,
 			    NULL, gio);
 
@@ -1902,9 +2004,12 @@ glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len,
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, 3.5.0);
+
+
 int
-glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len,
-                      glfs_io_cbk fn, void *data)
+pub_glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len,
+                         glfs_io_cbk fn, void *data)
 {
         struct glfs_io *gio  = NULL;
         int             ret  = 0;
@@ -1922,7 +2027,7 @@ glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len,
         gio->fn     = fn;
         gio->data   = data;
 
-        ret = synctask_new (glfs_from_glfd (glfd)->ctx->env,
+        ret = synctask_new (pub_glfs_from_glfd (glfd)->ctx->env,
                             glfs_io_async_task, glfs_io_async_cbk,
                             NULL, gio);
 
@@ -1934,6 +2039,8 @@ glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len,
         return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill_async, 3.5.0);
+
 
 void
 gf_dirent_to_dirent (gf_dirent_t *gf_dirent, struct dirent *dirent)
@@ -1965,7 +2072,7 @@ glfd_entry_refresh (struct glfs_fd *glfd, int plus)
 	int              ret = -1;
 	fd_t            *fd = NULL;
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2014,7 +2121,7 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
@@ -2076,8 +2183,8 @@ unlock:
 
 
 int
-glfs_readdirplus_r (struct glfs_fd *glfd, struct stat *stat, struct dirent *ext,
-		    struct dirent **res)
+pub_glfs_readdirplus_r (struct glfs_fd *glfd, struct stat *stat,
+                        struct dirent *ext, struct dirent **res)
 {
 	int              ret = 0;
 	gf_dirent_t     *entry = NULL;
@@ -2117,38 +2224,46 @@ glfs_readdirplus_r (struct glfs_fd *glfd, struct stat *stat, struct dirent *ext,
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus_r, 3.4.0);
+
 
 int
-glfs_readdir_r (struct glfs_fd *glfd, struct dirent *buf, struct dirent **res)
+pub_glfs_readdir_r (struct glfs_fd *glfd, struct dirent *buf,
+                    struct dirent **res)
 {
-	return glfs_readdirplus_r (glfd, 0, buf, res);
+	return pub_glfs_readdirplus_r (glfd, 0, buf, res);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir_r, 3.4.0);
+
 
 struct dirent *
-glfs_readdirplus (struct glfs_fd *glfd, struct stat *stat)
+pub_glfs_readdirplus (struct glfs_fd *glfd, struct stat *stat)
 {
         struct dirent *res = NULL;
         int ret = -1;
 
-        ret = glfs_readdirplus_r (glfd, stat, NULL, &res);
+        ret = pub_glfs_readdirplus_r (glfd, stat, NULL, &res);
         if (ret)
                 return NULL;
 
         return res;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus, 3.5.0);
 
 
 struct dirent *
-glfs_readdir (struct glfs_fd *glfd)
+pub_glfs_readdir (struct glfs_fd *glfd)
 {
-        return glfs_readdirplus (glfd, NULL);
+        return pub_glfs_readdirplus (glfd, NULL);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir, 3.5.0);
+
 
 int
-glfs_statvfs (struct glfs *fs, const char *path, struct statvfs *buf)
+pub_glfs_statvfs (struct glfs *fs, const char *path, struct statvfs *buf)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2158,7 +2273,7 @@ glfs_statvfs (struct glfs *fs, const char *path, struct statvfs *buf)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2179,11 +2294,13 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_statvfs, 3.4.0);
+
 
 int
 glfs_setattr (struct glfs *fs, const char *path, struct iatt *iatt,
@@ -2197,7 +2314,7 @@ glfs_setattr (struct glfs *fs, const char *path, struct iatt *iatt,
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2221,7 +2338,7 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
@@ -2236,7 +2353,7 @@ glfs_fsetattr (struct glfs_fd *glfd, struct iatt *iatt, int valid)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2256,14 +2373,14 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
 
 int
-glfs_chmod (struct glfs *fs, const char *path, mode_t mode)
+pub_glfs_chmod (struct glfs *fs, const char *path, mode_t mode)
 {
 	int              ret = -1;
 	struct iatt      iatt = {0, };
@@ -2277,9 +2394,11 @@ glfs_chmod (struct glfs *fs, const char *path, mode_t mode)
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chmod, 3.4.0);
+
 
 int
-glfs_fchmod (struct glfs_fd *glfd, mode_t mode)
+pub_glfs_fchmod (struct glfs_fd *glfd, mode_t mode)
 {
 	int              ret = -1;
 	struct iatt      iatt = {0, };
@@ -2293,9 +2412,11 @@ glfs_fchmod (struct glfs_fd *glfd, mode_t mode)
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchmod, 3.4.0);
+
 
 int
-glfs_chown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
+pub_glfs_chown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 {
 	int              ret = 0;
 	int              valid = 0;
@@ -2317,9 +2438,11 @@ glfs_chown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chown, 3.4.0);
+
 
 int
-glfs_lchown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
+pub_glfs_lchown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 {
 	int              ret = 0;
 	int              valid = 0;
@@ -2341,9 +2464,11 @@ glfs_lchown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lchown, 3.4.0);
+
 
 int
-glfs_fchown (struct glfs_fd *glfd, uid_t uid, gid_t gid)
+pub_glfs_fchown (struct glfs_fd *glfd, uid_t uid, gid_t gid)
 {
 	int              ret = 0;
 	int              valid = 0;
@@ -2365,9 +2490,11 @@ glfs_fchown (struct glfs_fd *glfd, uid_t uid, gid_t gid)
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchown, 3.4.0);
+
 
 int
-glfs_utimens (struct glfs *fs, const char *path, struct timespec times[2])
+pub_glfs_utimens (struct glfs *fs, const char *path, struct timespec times[2])
 {
 	int              ret = -1;
 	int              valid = 0;
@@ -2385,9 +2512,11 @@ glfs_utimens (struct glfs *fs, const char *path, struct timespec times[2])
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_utimens, 3.4.0);
+
 
 int
-glfs_lutimens (struct glfs *fs, const char *path, struct timespec times[2])
+pub_glfs_lutimens (struct glfs *fs, const char *path, struct timespec times[2])
 {
 	int              ret = -1;
 	int              valid = 0;
@@ -2405,9 +2534,11 @@ glfs_lutimens (struct glfs *fs, const char *path, struct timespec times[2])
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lutimens, 3.4.0);
+
 
 int
-glfs_futimens (struct glfs_fd *glfd, struct timespec times[2])
+pub_glfs_futimens (struct glfs_fd *glfd, struct timespec times[2])
 {
 	int              ret = -1;
 	int              valid = 0;
@@ -2425,6 +2556,8 @@ glfs_futimens (struct glfs_fd *glfd, struct timespec times[2])
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_futimens, 3.4.0);
+
 
 int
 glfs_getxattr_process (void *value, size_t size, dict_t *xattr,
@@ -2471,7 +2604,7 @@ glfs_getxattr_common (struct glfs *fs, const char *path, const char *name,
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2500,31 +2633,35 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
 
 ssize_t
-glfs_getxattr (struct glfs *fs, const char *path, const char *name,
-	       void *value, size_t size)
+pub_glfs_getxattr (struct glfs *fs, const char *path, const char *name,
+                   void *value, size_t size)
 {
 	return glfs_getxattr_common (fs, path, name, value, size, 1);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getxattr, 3.4.0);
+
 
 ssize_t
-glfs_lgetxattr (struct glfs *fs, const char *path, const char *name,
-		void *value, size_t size)
+pub_glfs_lgetxattr (struct glfs *fs, const char *path, const char *name,
+                    void *value, size_t size)
 {
 	return glfs_getxattr_common (fs, path, name, value, size, 0);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lgetxattr, 3.4.0);
+
 
 ssize_t
-glfs_fgetxattr (struct glfs_fd *glfd, const char *name, void *value,
-		size_t size)
+pub_glfs_fgetxattr (struct glfs_fd *glfd, const char *name, void *value,
+                    size_t size)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2533,7 +2670,7 @@ glfs_fgetxattr (struct glfs_fd *glfd, const char *name, void *value,
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2557,11 +2694,13 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fgetxattr, 3.4.0);
+
 
 int
 glfs_listxattr_process (void *value, size_t size, dict_t *xattr)
@@ -2604,7 +2743,7 @@ glfs_listxattr_common (struct glfs *fs, const char *path, void *value,
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2634,28 +2773,32 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
 
 ssize_t
-glfs_listxattr (struct glfs *fs, const char *path, void *value, size_t size)
+pub_glfs_listxattr (struct glfs *fs, const char *path, void *value, size_t size)
 {
 	return glfs_listxattr_common (fs, path, value, size, 1);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_listxattr, 3.4.0);
+
 
 ssize_t
-glfs_llistxattr (struct glfs *fs, const char *path, void *value, size_t size)
+pub_glfs_llistxattr (struct glfs *fs, const char *path, void *value, size_t size)
 {
 	return glfs_listxattr_common (fs, path, value, size, 0);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_llistxattr, 3.4.0);
+
 
 ssize_t
-glfs_flistxattr (struct glfs_fd *glfd, void *value, size_t size)
+pub_glfs_flistxattr (struct glfs_fd *glfd, void *value, size_t size)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2664,7 +2807,7 @@ glfs_flistxattr (struct glfs_fd *glfd, void *value, size_t size)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2688,11 +2831,13 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_flistxattr, 3.4.0);
+
 
 dict_t *
 dict_for_key_value (const char *name, const char *value, size_t size)
@@ -2727,7 +2872,7 @@ glfs_setxattr_common (struct glfs *fs, const char *path, const char *name,
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2761,31 +2906,35 @@ out:
 	if (xattr)
 		dict_unref (xattr);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
 
 int
-glfs_setxattr (struct glfs *fs, const char *path, const char *name,
-	       const void *value, size_t size, int flags)
+pub_glfs_setxattr (struct glfs *fs, const char *path, const char *name,
+                   const void *value, size_t size, int flags)
 {
 	return glfs_setxattr_common (fs, path, name, value, size, flags, 1);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setxattr, 3.4.0);
+
 
 int
-glfs_lsetxattr (struct glfs *fs, const char *path, const char *name,
-		const void *value, size_t size, int flags)
+pub_glfs_lsetxattr (struct glfs *fs, const char *path, const char *name,
+                    const void *value, size_t size, int flags)
 {
 	return glfs_setxattr_common (fs, path, name, value, size, flags, 0);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lsetxattr, 3.4.0);
+
 
 int
-glfs_fsetxattr (struct glfs_fd *glfd, const char *name, const void *value,
-		size_t size, int flags)
+pub_glfs_fsetxattr (struct glfs_fd *glfd, const char *name, const void *value,
+                    size_t size, int flags)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2794,7 +2943,7 @@ glfs_fsetxattr (struct glfs_fd *glfd, const char *name, const void *value,
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2824,11 +2973,13 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsetxattr, 3.4.0);
+
 
 int
 glfs_removexattr_common (struct glfs *fs, const char *path, const char *name,
@@ -2842,7 +2993,7 @@ glfs_removexattr_common (struct glfs *fs, const char *path, const char *name,
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2867,28 +3018,32 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
 
 int
-glfs_removexattr (struct glfs *fs, const char *path, const char *name)
+pub_glfs_removexattr (struct glfs *fs, const char *path, const char *name)
 {
 	return glfs_removexattr_common (fs, path, name, 1);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_removexattr, 3.4.0);
+
 
 int
-glfs_lremovexattr (struct glfs *fs, const char *path, const char *name)
+pub_glfs_lremovexattr (struct glfs *fs, const char *path, const char *name)
 {
 	return glfs_removexattr_common (fs, path, name, 0);
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lremovexattr, 3.4.0);
+
 
 int
-glfs_fremovexattr (struct glfs_fd *glfd, const char *name)
+pub_glfs_fremovexattr (struct glfs_fd *glfd, const char *name)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2896,7 +3051,7 @@ glfs_fremovexattr (struct glfs_fd *glfd, const char *name)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2916,14 +3071,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fremovexattr, 3.4.0);
+
 
 int
-glfs_fallocate (struct glfs_fd *glfd, int keep_size, off_t offset, size_t len)
+pub_glfs_fallocate (struct glfs_fd *glfd, int keep_size, off_t offset, size_t len)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2931,7 +3088,7 @@ glfs_fallocate (struct glfs_fd *glfd, int keep_size, off_t offset, size_t len)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2951,14 +3108,16 @@ out:
 	if (fd)
 		fd_unref(fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fallocate, 3.5.0);
+
 
 int
-glfs_discard (struct glfs_fd *glfd, off_t offset, size_t len)
+pub_glfs_discard (struct glfs_fd *glfd, off_t offset, size_t len)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -2966,7 +3125,7 @@ glfs_discard (struct glfs_fd *glfd, off_t offset, size_t len)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -2986,13 +3145,16 @@ out:
 	if (fd)
 		fd_unref(fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard, 3.5.0);
+
+
 int
-glfs_zerofill (struct glfs_fd *glfd, off_t offset, off_t len)
+pub_glfs_zerofill (struct glfs_fd *glfd, off_t offset, off_t len)
 {
         int               ret             = -1;
         xlator_t         *subvol          = NULL;
@@ -3000,7 +3162,7 @@ glfs_zerofill (struct glfs_fd *glfd, off_t offset, off_t len)
 
         __glfs_entry_fd (glfd);
 
-        subvol = glfs_active_subvol (glfd->fs);
+        subvol = priv_glfs_active_subvol (glfd->fs);
         if (!subvol) {
                 errno = EIO;
                 goto out;
@@ -3018,13 +3180,16 @@ out:
         if (fd)
                 fd_unref(fd);
 
-        glfs_subvol_done (glfd->fs, subvol);
+        priv_glfs_subvol_done (glfd->fs, subvol);
 
         return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill, 3.5.0);
+
+
 int
-glfs_chdir (struct glfs *fs, const char *path)
+pub_glfs_chdir (struct glfs *fs, const char *path)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -3034,7 +3199,7 @@ glfs_chdir (struct glfs *fs, const char *path)
 
 	__glfs_entry_fs (fs);
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -3059,14 +3224,16 @@ retry:
 out:
 	loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chdir, 3.4.0);
+
 
 int
-glfs_fchdir (struct glfs_fd *glfd)
+pub_glfs_fchdir (struct glfs_fd *glfd)
 {
 	int       ret = -1;
 	inode_t  *inode = NULL;
@@ -3075,7 +3242,7 @@ glfs_fchdir (struct glfs_fd *glfd)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -3103,14 +3270,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0);
+
 
 char *
-glfs_realpath (struct glfs *fs, const char *path, char *resolved_path)
+pub_glfs_realpath (struct glfs *fs, const char *path, char *resolved_path)
 {
 	int              ret = -1;
 	char            *retpath = NULL;
@@ -3133,7 +3302,7 @@ glfs_realpath (struct glfs *fs, const char *path, char *resolved_path)
 		goto out;
 	}
 
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -3161,14 +3330,16 @@ out:
 		retpath = NULL;
 	}
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return retpath;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_realpath, 3.4.0);
+
 
 char *
-glfs_getcwd (struct glfs *fs, char *buf, size_t n)
+pub_glfs_getcwd (struct glfs *fs, char *buf, size_t n)
 {
 	int              ret = -1;
 	inode_t         *inode = NULL;
@@ -3211,6 +3382,8 @@ out:
 	return buf;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getcwd, 3.4.0);
+
 
 static void
 gf_flock_to_flock (struct gf_flock *gf_flock, struct flock *flock)
@@ -3235,7 +3408,7 @@ gf_flock_from_flock (struct gf_flock *gf_flock, struct flock *flock)
 
 
 int
-glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock)
+pub_glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock)
 {
 	int              ret = -1;
 	xlator_t        *subvol = NULL;
@@ -3245,7 +3418,7 @@ glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock)
 
 	__glfs_entry_fd (glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
+	subvol = priv_glfs_active_subvol (glfd->fs);
 	if (!subvol) {
 		ret = -1;
 		errno = EIO;
@@ -3271,14 +3444,16 @@ out:
 	if (fd)
 		fd_unref (fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+	priv_glfs_subvol_done (glfd->fs, subvol);
 
 	return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0);
+
 
 struct glfs_fd *
-glfs_dup (struct glfs_fd *glfd)
+pub_glfs_dup (struct glfs_fd *glfd)
 {
 	xlator_t  *subvol = NULL;
 	fd_t      *fd = NULL;
@@ -3288,7 +3463,7 @@ glfs_dup (struct glfs_fd *glfd)
 	__glfs_entry_fd (glfd);
 
 	fs = glfd->fs;
-	subvol = glfs_active_subvol (fs);
+	subvol = priv_glfs_active_subvol (fs);
 	if (!subvol) {
 		errno = EIO;
 		goto out;
@@ -3313,7 +3488,10 @@ out:
 	if (dupfd)
 		glfs_fd_bind (dupfd);
 
-	glfs_subvol_done (fs, subvol);
+	priv_glfs_subvol_done (fs, subvol);
 
 	return dupfd;
 }
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_dup, 3.4.0);
+