nfs: Add MOUNTv3 protocol support

Signed-off-by: Shehjar Tikoo <shehjart@gluster.com>
Signed-off-by: Anand V. Avati <avati@dev.gluster.com>

BUG: 399 (NFS translator with Mount v3 and NFS v3 support)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=399

6 files changed, 1390 insertions, 3 deletions

diff --git a/xlators/nfs/server/src/Makefile.am b/xlators/nfs/server/src/Makefile.am
index 453fd4753fc..9661dd95d20 100644
--- a/xlators/nfs/server/src/Makefile.am
+++ b/xlators/nfs/server/src/Makefile.am
@@ -2,10 +2,10 @@ xlator_LTLIBRARIES = server.la
 xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/nfs
 rpclibdir = $(top_srcdir)/xlators/nfs/lib/src/
 server_la_LDFLAGS = -module -avoidversion
-server_la_SOURCES = nfs.c nfs-common.c nfs-fops.c nfs-inodes.c nfs-generics.c
+server_la_SOURCES = nfs.c nfs-common.c nfs-fops.c nfs-inodes.c nfs-generics.c mount3.c nfs3-fh.c
 server_la_LIBADD = $(top_builddir)/xlators/nfs/lib/src/librpcsvc.la $(top_builddir)/libglusterfs/src/libglusterfs.la
 
-noinst_HEADERS = nfs.h nfs-common.h nfs-fops.h nfs-inodes.h nfs-generics.h
+noinst_HEADERS = nfs.h nfs-common.h nfs-fops.h nfs-inodes.h nfs-generics.h mount3.h nfs3-fh.h
 
 AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS)\
 	-I$(top_srcdir)/libglusterfs/src -shared -nostartfiles $(GF_CFLAGS)\
diff --git a/xlators/nfs/server/src/mount3.c b/xlators/nfs/server/src/mount3.c
new file mode 100644
index 00000000000..dc880508590
--- /dev/null
+++ b/xlators/nfs/server/src/mount3.c
@@ -0,0 +1,914 @@
+/*
+  Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "rpcsvc.h"
+#include "dict.h"
+#include "xlator.h"
+#include "mount3.h"
+#include "xdr-nfs3.h"
+#include "msg-nfs3.h"
+#include "iobuf.h"
+#include "nfs-common.h"
+#include "nfs3-fh.h"
+#include "nfs-fops.h"
+#include "nfs-inodes.h"
+#include "nfs-generics.h"
+#include "locking.h"
+#include "iatt.h"
+
+
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+
+typedef ssize_t (*mnt3_serializer) (struct iovec outmsg, void *args);
+
+
+/* Generic reply function for MOUNTv3 specific replies. */
+int
+mnt3svc_submit_reply (rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc)
+{
+        struct iovec            outmsg = {0, };
+        struct iobuf            *iob = NULL;
+        struct mount3_state     *ms = NULL;
+        int                     ret = -1;
+
+        if (!req)
+                return -1;
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "mount state not found");
+                goto ret;
+        }
+
+        /* First, get the io buffer into which the reply in arg will
+         * be serialized.
+         */
+        iob = iobuf_get (ms->iobpool);
+        if (!iob) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get iobuf");
+                goto ret;
+        }
+
+        iobuf_to_iovec (iob, &outmsg);
+        /* Use the given serializer to translate the give C structure in arg
+         * to XDR format which will be written into the buffer in outmsg.
+         */
+        outmsg.iov_len = sfunc (outmsg, arg);
+
+        /* Then, submit the message for transmission. */
+        ret = rpcsvc_submit_message (req, outmsg, iob);
+        iobuf_unref (iob);
+        if (ret == -1) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Reply submission failed");
+                goto ret;
+        }
+
+        ret = 0;
+ret:
+        return ret;
+}
+
+
+/* Generic error reply function, just pass the err status
+ * and it will do the rest, including transmission.
+ */
+int
+mnt3svc_mnt_error_reply (rpcsvc_request_t *req, int mntstat)
+{
+        mountres3       res;
+
+        if (!req)
+                return -1;
+
+        res.fhs_status = mntstat;
+        mnt3svc_submit_reply (req, (void *)&res,
+                              (mnt3_serializer)xdr_serialize_mountres3);
+
+        return 0;
+}
+
+
+mountstat3
+mnt3svc_errno_to_mnterr (int32_t errnum)
+{
+        mountstat3      stat;
+
+        switch (errnum) {
+
+                case 0:
+                        stat = MNT3_OK;
+                        break;
+                case ENOENT:
+                        stat = MNT3ERR_NOENT;
+                        break;
+                case EPERM:
+                        stat = MNT3ERR_PERM;
+                        break;
+                case EIO:
+                        stat = MNT3ERR_IO;
+                        break;
+                case EACCES:
+                        stat = MNT3ERR_ACCES;
+                        break;
+                case ENOTDIR:
+                        stat = MNT3ERR_NOTDIR;
+                        break;
+                case EINVAL:
+                        stat = MNT3ERR_INVAL;
+                        break;
+                case ENOSYS:
+                        stat = MNT3ERR_NOTSUPP;
+                        break;
+                case ENOMEM:
+                        stat = MNT3ERR_SERVERFAULT;
+                        break;
+                default:
+                        stat = MNT3ERR_SERVERFAULT;
+                        break;
+        }
+
+        return stat;
+}
+
+
+mountres3
+mnt3svc_set_mountres3 (mountstat3 stat, struct nfs3_fh *fh, int *authflavor,
+                       u_int aflen)
+{
+        mountres3       res = {0, };
+        uint32_t        fhlen = 0;
+
+        res.fhs_status = stat;
+        fhlen = nfs3_fh_compute_size (fh);
+        res.mountres3_u.mountinfo.fhandle.fhandle3_len = fhlen;
+        res.mountres3_u.mountinfo.fhandle.fhandle3_val = (char *)fh;
+        res.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = authflavor;
+        res.mountres3_u.mountinfo.auth_flavors.auth_flavors_len = aflen;
+
+        return res;
+}
+
+
+int
+mnt3svc_update_mountlist (struct mount3_state *ms, rpcsvc_request_t *req,
+                          xlator_t *exportxl)
+{
+        struct mountentry       *me = NULL;
+        int                     ret = -1;
+
+        if ((!ms) || (!req) || (!exportxl))
+                return -1;
+
+        me = (struct mountentry *)CALLOC (1, sizeof (*me));
+        if (!me)
+                return -1;
+
+        strcpy (me->exname, exportxl->name);
+        INIT_LIST_HEAD (&me->mlist);
+        /* Must get the IP or hostname of the client so we
+         * can map it into the mount entry.
+         */
+        ret = rpcsvc_conn_peername (req->conn, me->hostname, MNTPATHLEN);
+        if (ret == -1)
+                goto free_err;
+
+        LOCK (&ms->mountlock);
+        {
+                list_add_tail (&me->mlist, &ms->mountlist);
+        }
+        UNLOCK (&ms->mountlock);
+
+free_err:
+        if (ret == -1)
+                FREE (me);
+
+        return ret;
+}
+
+
+int32_t
+mnt3svc_lookup_mount_cbk (call_frame_t *frame, void  *cookie,
+                          xlator_t *this, int32_t op_ret, int32_t op_errno,
+                          inode_t *inode, struct iatt *buf, dict_t *xattr,
+                          struct iatt *postparent)
+{
+        mountres3               res = {0, };
+        rpcsvc_request_t        *req = NULL;
+        struct nfs3_fh          fh = {{0}, };
+        struct mount3_state     *ms = NULL;
+        xlator_t                *exportxl = NULL;
+        mountstat3              status = 0;
+        int                     autharr[10];
+        int                     autharrlen = 0;
+        rpcsvc_t                *svc = NULL;
+
+        req = (rpcsvc_request_t *)frame->local;
+
+        if (!req)
+                return -1;
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "mount state not found");
+                op_ret = -1;
+                op_errno = EINVAL;
+        }
+
+        if (op_ret == -1)
+                status = mnt3svc_errno_to_mnterr (op_errno);
+
+        if (status != MNT3_OK)
+                goto xmit_res;
+
+        exportxl = (xlator_t *)cookie;
+        fh = nfs3_fh_build_root_fh (ms->nfsx->children, exportxl, *buf);
+        mnt3svc_update_mountlist (ms, req, exportxl);
+xmit_res:
+        gf_log (GF_MNT, GF_LOG_DEBUG, "Mount reply status: %d", status);
+        if (op_ret == 0) {
+                svc = rpcsvc_request_service (req);
+                autharrlen = rpcsvc_auth_array (svc, exportxl->name, autharr,
+                                                10);
+        }
+
+        res = mnt3svc_set_mountres3 (status, &fh, autharr, autharrlen);
+        mnt3svc_submit_reply (req, (void *)&res,
+                              (mnt3_serializer)xdr_serialize_mountres3);
+
+        return 0;
+}
+
+
+int
+mnt3svc_mount (rpcsvc_request_t *req, xlator_t * xl)
+{
+        loc_t           oploc = {0, };
+        int             ret = -1;
+        nfs_user_t      nfu = {0, };
+
+        if ((!req) || (!xl))
+                return ret;
+
+        ret = nfs_ino_loc_fill (xl->itable, 1, 0, &oploc);
+        /* To service the mount request, all we need to do
+         * is to send a lookup fop that returns the stat
+         * for the root of the child volume. This is
+         * used to build the root fh sent to the client.
+         */
+        nfs_request_user_init (&nfu, req);
+        ret = nfs_lookup (xl, &nfu, &oploc, mnt3svc_lookup_mount_cbk,
+                          (void *)req);
+        nfs_loc_wipe (&oploc);
+
+        return ret;
+}
+
+
+int
+mnt3svc_mnt (rpcsvc_request_t *req)
+{
+        struct iovec            pvec = {0, };
+        char                    path[MNTPATHLEN];
+        int                     ret = -1;
+        xlator_t                *targetxl = NULL;
+        struct mount3_state     *ms = NULL;
+        rpcsvc_t                *svc = NULL;
+        mountstat3              mntstat = MNT3ERR_SERVERFAULT;
+
+        if (!req)
+                return -1;
+
+        pvec.iov_base = path;
+        pvec.iov_len = MNTPATHLEN;
+        ret = xdr_to_mountpath (pvec, req->msg);
+        if (ret == -1) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Failed to decode args");
+                rpcsvc_request_seterr (req, GARBAGE_ARGS);
+                goto rpcerr;
+        }
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present");
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                ret = -1;
+                goto rpcerr;
+        }
+
+        ret = 0;
+        gf_log (GF_MNT, GF_LOG_DEBUG, "dirpath: %s", path);
+        targetxl = nfs_mntpath_to_xlator (ms->nfsx->children, path);
+        if (!targetxl) {
+                ret = -1;
+                mntstat = MNT3ERR_NOENT;
+                goto mnterr;
+        }
+
+        svc = rpcsvc_request_service (req);
+        ret = rpcsvc_conn_peer_check (svc->options, targetxl->name,
+                                      rpcsvc_request_conn (req));
+        if (ret == RPCSVC_AUTH_REJECT) {
+                mntstat = MNT3ERR_ACCES;
+                ret = -1;
+                gf_log (GF_MNT, GF_LOG_TRACE, "Peer not allowed");
+                goto mnterr;
+        }
+
+        ret = rpcsvc_conn_privport_check (svc, targetxl->name,
+                                          rpcsvc_request_conn (req));
+        if (ret == RPCSVC_AUTH_REJECT) {
+                mntstat = MNT3ERR_ACCES;
+                ret = -1;
+                gf_log (GF_MNT, GF_LOG_TRACE, "Unprivileged port not allowed");
+                goto rpcerr;
+        }
+
+        mnt3svc_mount (req, targetxl);
+mnterr:
+        if (ret == -1) {
+                mnt3svc_mnt_error_reply (req, mntstat);
+                ret = 0;
+        }
+
+rpcerr:
+        return ret;
+}
+
+
+int
+mnt3svc_null (rpcsvc_request_t *req)
+{
+        struct iovec    dummyvec = {0, };
+
+        if (!req) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Got NULL request!");
+                return 0;
+        }
+
+        rpcsvc_submit_generic (req, dummyvec, NULL);
+        return 0;
+}
+
+
+mountlist
+__build_mountlist (struct mount3_state *ms, int *count)
+{
+        struct mountbody        *mlist = NULL;
+        struct mountbody        *prev = NULL;
+        struct mountbody        *first = NULL;
+        size_t                  namelen = 0;
+        int                     ret = -1;
+        struct mountentry       *me = NULL;
+
+        if ((!ms) || (!count))
+                return NULL;
+
+        *count = 0;
+        gf_log (GF_MNT, GF_LOG_DEBUG, "Building mount list:");
+        list_for_each_entry (me, &ms->mountlist, mlist) {
+                namelen = strlen (me->exname);
+                mlist = CALLOC (1, sizeof (*mlist));
+                if (!mlist) {
+                        gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation"
+                                " failed");
+                        goto free_list;
+                }
+
+                mlist->ml_directory = CALLOC (namelen + 2, sizeof (char));
+                if (!mlist->ml_directory) {
+                        gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation"
+                                " failed");
+                        goto free_list;
+                }
+
+                strcpy (mlist->ml_directory, "/");
+                strcat (mlist->ml_directory, me->exname);
+
+                namelen = strlen (me->hostname);
+                mlist->ml_hostname = CALLOC (namelen + 2, sizeof (char));
+                if (!mlist->ml_hostname) {
+                        gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation"
+                                " failed");
+                        goto free_list;
+                }
+
+                strcat (mlist->ml_hostname, me->hostname);
+
+                gf_log (GF_MNT, GF_LOG_DEBUG, "mount entry: dir: %s, host: %s",
+                        mlist->ml_directory, mlist->ml_hostname);
+                if (prev) {
+                        prev->ml_next = mlist;
+                        prev = mlist;
+                } else
+                        prev = mlist;
+
+                if (!first)
+                        first = mlist;
+
+                (*count)++;
+        }
+
+        ret = 0;
+
+free_list:
+        if (ret == -1) {
+                xdr_free_mountlist (first);
+                first = NULL;
+        }
+
+        return first;
+}
+
+
+mountlist
+mnt3svc_build_mountlist (struct mount3_state *ms, int *count)
+{
+        struct mountbody        *first = NULL;
+
+        LOCK (&ms->mountlock);
+        {
+                first = __build_mountlist (ms, count);
+        }
+        UNLOCK (&ms->mountlock);
+
+        return first;
+}
+
+
+int
+mnt3svc_dump (rpcsvc_request_t *req)
+{
+        int                     ret = -1;
+        struct mount3_state     *ms = NULL;
+        mountlist               mlist;
+        mountstat3              mstat = 0;
+        mnt3_serializer         sfunc = NULL;
+        void                    *arg = NULL;
+
+
+        if (!req)
+                return -1;
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                goto rpcerr;
+        }
+
+        sfunc = (mnt3_serializer)xdr_serialize_mountlist;
+        mlist = mnt3svc_build_mountlist (ms, &ret);
+        arg = mlist;
+        sfunc = (mnt3_serializer)xdr_serialize_mountlist;
+        if (!mlist) {
+                if (ret != 0) {
+                        rpcsvc_request_seterr (req, SYSTEM_ERR);
+                        ret = -1;
+                        goto rpcerr;
+                } else {
+                        arg = &mstat;
+                        sfunc = (mnt3_serializer)xdr_serialize_mountstat3;
+                }
+        }
+
+        mnt3svc_submit_reply (req, arg, sfunc);
+
+        xdr_free_mountlist (mlist);
+        ret = 0;
+
+rpcerr:
+        return ret;
+}
+
+
+int
+__mnt3svc_umount (struct mount3_state *ms, char *dirpath, char *hostname)
+{
+        struct mountentry       *me = NULL;
+        char                    *exname = NULL;
+        int                     ret = -1;
+
+        if ((!ms) || (!dirpath) || (!hostname))
+                return -1;
+
+        if (list_empty (&ms->mountlist))
+                return 0;
+
+        list_for_each_entry (me, &ms->mountlist, mlist) {
+                exname = dirpath+1;
+                if ((strcmp (me->exname, exname) == 0) &&
+                    (strcmp (me->hostname, hostname) == 0))
+                        break;
+        }
+
+        if (!me)
+                goto ret;
+
+        gf_log (GF_MNT, GF_LOG_DEBUG, "Unmounting: dir %s, host: %s",
+                me->exname, me->hostname);
+        list_del (&me->mlist);
+        FREE (me);
+        ret = 0;
+ret:
+        return ret;
+}
+
+
+
+int
+mnt3svc_umount (struct mount3_state *ms, char *dirpath, char *hostname)
+{
+        int ret = -1;
+        if ((!ms) || (!dirpath) || (!hostname))
+                return -1;
+
+        LOCK (&ms->mountlock);
+        {
+               ret = __mnt3svc_umount (ms, dirpath, hostname);
+        }
+        UNLOCK (&ms->mountlock);
+
+        return ret;
+}
+
+
+int
+mnt3svc_umnt (rpcsvc_request_t *req)
+{
+        char                    hostname[MNTPATHLEN];
+        char                    dirpath[MNTPATHLEN];
+        struct iovec            pvec = {0, };
+        int                     ret = -1;
+        struct mount3_state     *ms = NULL;
+        mountstat3              mstat = MNT3_OK;
+
+        if (!req)
+                return -1;
+
+        /* Remove the mount point from the exports list. */
+        pvec.iov_base = dirpath;
+        pvec.iov_len = MNTPATHLEN;
+        ret = xdr_to_mountpath (pvec, req->msg);;
+        if (ret == -1) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Failed decode args");
+                rpcsvc_request_seterr (req, GARBAGE_ARGS);
+                goto rpcerr;
+        }
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present");
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                ret = -1;
+                goto rpcerr;
+        }
+
+        ret = rpcsvc_conn_peername (req->conn, hostname, MNTPATHLEN);
+        if (ret != 0) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get remote name: %s",
+                        gai_strerror (ret));
+                goto try_umount_with_addr;
+        }
+
+        gf_log (GF_MNT, GF_LOG_DEBUG, "dirpath: %s, hostname: %s", dirpath,
+                hostname);
+        ret = mnt3svc_umount (ms, dirpath, hostname);
+
+        /* Unmount succeeded with the given hostname. */
+        if (ret == 0)
+                goto snd_reply;
+
+try_umount_with_addr:
+        if (ret != 0)
+                ret = rpcsvc_conn_peeraddr (req->conn, hostname, MNTPATHLEN,
+                                            NULL, 0);
+
+        if (ret != 0) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get remote addr: %s",
+                        gai_strerror (ret));
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                goto rpcerr;
+        }
+
+        gf_log (GF_MNT, GF_LOG_DEBUG, "dirpath: %s, hostname: %s", dirpath,
+                hostname);
+        ret = mnt3svc_umount (ms, dirpath, hostname);
+        if (ret == -1)
+                mstat = MNT3ERR_INVAL;
+
+        ret = 0;
+snd_reply:
+        mnt3svc_submit_reply (req, &mstat,
+                              (mnt3_serializer)xdr_serialize_mountstat3);
+
+rpcerr:
+        return ret;
+}
+
+
+int
+__mnt3svc_umountall (struct mount3_state *ms)
+{
+        struct mountentry       *me = NULL;
+
+        if (!ms)
+                return -1;
+
+        list_for_each_entry (me, &ms->mountlist, mlist) {
+                list_del (&me->mlist);
+                FREE (me);
+        }
+
+        return 0;
+}
+
+
+int
+mnt3svc_umountall (struct mount3_state *ms)
+{
+        int     ret = -1;
+        if (!ms)
+                return -1;
+
+        LOCK (&ms->mountlock);
+        {
+               ret = __mnt3svc_umountall (ms);
+        }
+        UNLOCK (&ms->mountlock);
+
+        return ret;
+}
+
+
+int
+mnt3svc_umntall (rpcsvc_request_t *req)
+{
+        int                     ret = -1;
+        struct mount3_state     *ms = NULL;
+        mountstat3              mstat = MNT3_OK;
+
+        if (!req)
+                return -1;
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present");
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                ret = -1;
+                goto rpcerr;
+        }
+
+        mnt3svc_umountall (ms);
+        mnt3svc_submit_reply (req, &mstat,
+                              (mnt3_serializer)xdr_serialize_mountstat3);
+
+rpcerr:
+        return ret;
+}
+
+
+exports
+mnt3_xlchildren_to_exports (rpcsvc_t *svc, xlator_list_t *cl)
+{
+        struct exportnode       *elist = NULL;
+        struct exportnode       *prev = NULL;
+        struct exportnode       *first = NULL;
+        size_t                  namelen = 0;
+        int                     ret = -1;
+        char                    *addrstr = NULL;
+
+        if ((!cl) || (!svc))
+                return NULL;
+
+        while (cl) {
+                namelen = strlen (cl->xlator->name);
+                elist = CALLOC (1, sizeof (*elist));
+                if (!elist) {
+                        gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation"
+                                " failed");
+                        goto free_list;
+                }
+
+                elist->ex_dir = CALLOC (namelen + 2, sizeof (char));
+                if (!elist->ex_dir) {
+                        gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation"
+                                " failed");
+                        goto free_list;
+                }
+
+                strcpy (elist->ex_dir, "/");
+                strcat (elist->ex_dir, cl->xlator->name);
+
+                addrstr = rpcsvc_volume_allowed (svc->options,cl->xlator->name);
+                if (addrstr)
+                        addrstr = strdup (addrstr);
+                else
+                        addrstr = strdup ("No Access");
+
+                elist->ex_groups = CALLOC (1, sizeof (struct groupnode));
+                if (!elist->ex_groups) {
+                        gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation"
+                                " failed");
+                        goto free_list;
+                }
+
+                elist->ex_groups->gr_name = addrstr;
+                if (prev) {
+                        prev->ex_next = elist;
+                        prev = elist;
+                } else
+                        prev = elist;
+
+                if (!first)
+                        first = elist;
+
+                cl = cl->next;
+        }
+
+        ret = 0;
+
+free_list:
+        if (ret == -1) {
+                xdr_free_exports_list (first);
+                first = NULL;
+        }
+
+        return first;
+}
+
+
+int
+mnt3svc_export (rpcsvc_request_t *req)
+{
+        struct mount3_state     *ms = NULL;
+        exports                 elist = NULL;
+        int                     ret = -1;
+
+        if (!req)
+                return -1;
+
+        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "mount state not found");
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                goto err;
+        }
+
+        /* Using the children translator names, build the export list */
+        elist = mnt3_xlchildren_to_exports (rpcsvc_request_service (req),
+                                            ms->nfsx->children);
+        if (!elist) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Failed to build exports list");
+                rpcsvc_request_seterr (req, SYSTEM_ERR);
+                goto err;
+        }
+
+        /* Note how the serializer is passed to the generic reply function. */
+        mnt3svc_submit_reply (req, &elist,
+                              (mnt3_serializer)xdr_serialize_exports);
+
+        xdr_free_exports_list (elist);
+        ret = 0;
+err:
+        return ret;
+}
+
+
+struct mount3_state *
+mnt3_init_state (xlator_t *nfsx)
+{
+        struct mount3_state     *ms = NULL;
+
+        if (!nfsx)
+                return NULL;
+
+        ms = CALLOC (1, sizeof (*ms));
+        if (!ms) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed");
+                return NULL;
+        }
+
+        ms->iobpool = nfsx->ctx->iobuf_pool;
+        ms->nfsx = nfsx;
+        ms->exports = nfsx->children;
+        INIT_LIST_HEAD (&ms->mountlist);
+        LOCK_INIT (&ms->mountlock);
+
+        return ms;
+}
+
+rpcsvc_actor_t  mnt3svc_actors[MOUNT3_PROC_COUNT] = {
+        {"NULL", MOUNT3_NULL, mnt3svc_null, NULL, NULL},
+        {"MNT", MOUNT3_MNT, mnt3svc_mnt, NULL, NULL},
+        {"DUMP", MOUNT3_DUMP, mnt3svc_dump, NULL, NULL},
+        {"UMNT", MOUNT3_UMNT, mnt3svc_umnt, NULL, NULL},
+        {"UMNTALL", MOUNT3_UMNTALL, mnt3svc_umntall, NULL, NULL},
+        {"EXPORT", MOUNT3_EXPORT, mnt3svc_export, NULL, NULL}
+};
+
+
+
+/* Static init parts are assigned here, dynamic ones are done in
+ * mnt3svc_init and mnt3_init_state.
+ */
+rpcsvc_program_t        mnt3prog = {
+                        .progname       = "MOUNT3",
+                        .prognum        = MOUNT_PROGRAM,
+                        .progver        = MOUNT_V3,
+                        .progport       = GF_MOUNTV3_PORT,
+                        .progaddrfamily = AF_INET,
+                        .proghost       = NULL,
+                        .actors         = mnt3svc_actors,
+                        .numactors      = MOUNT3_PROC_COUNT,
+};
+
+
+rpcsvc_program_t *
+mnt3svc_init (xlator_t *nfsx)
+{
+        struct mount3_state     *mstate = NULL;
+
+        if (!nfsx)
+                return NULL;
+
+        gf_log (GF_MNT, GF_LOG_DEBUG, "Initing Mount v3 state");
+        mstate = mnt3_init_state (nfsx);
+        if (!mstate) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Mount v3 state init failed");
+                goto err;
+        }
+
+        mnt3prog.private = mstate;
+
+        return &mnt3prog;
+err:
+        return NULL;
+}
+
+
+rpcsvc_actor_t  mnt1svc_actors[MOUNT1_PROC_COUNT] = {
+        {"NULL", MOUNT1_NULL, mnt3svc_null, NULL, NULL},
+        {{0}, },
+        {"DUMP", MOUNT1_DUMP, mnt3svc_dump, NULL, NULL},
+        {"UMNT", MOUNT1_UMNT, mnt3svc_umnt, NULL, NULL},
+        {{0}, },
+        {"EXPORT", MOUNT1_EXPORT, mnt3svc_export, NULL, NULL}
+};
+
+rpcsvc_program_t        mnt1prog = {
+                        .progname       = "MOUNT1",
+                        .prognum        = MOUNT_PROGRAM,
+                        .progver        = MOUNT_V1,
+                        .progport       = GF_MOUNTV1_PORT,
+                        .progaddrfamily = AF_INET,
+                        .proghost       = NULL,
+                        .actors         = mnt1svc_actors,
+                        .numactors      = MOUNT1_PROC_COUNT,
+};
+
+
+rpcsvc_program_t *
+mnt1svc_init (xlator_t *nfsx)
+{
+        struct mount3_state     *mstate = NULL;
+
+        if (!nfsx)
+                return NULL;
+
+        gf_log (GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state");
+        mstate = mnt3_init_state (nfsx);
+        if (!mstate) {
+                gf_log (GF_MNT, GF_LOG_ERROR, "Mount v3 state init failed");
+                goto err;
+        }
+
+        mnt1prog.private = mstate;
+
+        return &mnt1prog;
+err:
+        return NULL;
+}
+
+
diff --git a/xlators/nfs/server/src/mount3.h b/xlators/nfs/server/src/mount3.h
new file mode 100644
index 00000000000..7cfd2b0cb84
--- /dev/null
+++ b/xlators/nfs/server/src/mount3.h
@@ -0,0 +1,78 @@
+/*
+  Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _MOUNT3_H_
+#define _MOUNT3_H_
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "rpcsvc.h"
+#include "dict.h"
+#include "xlator.h"
+#include "iobuf.h"
+#include "nfs.h"
+#include "list.h"
+#include "xdr-nfs3.h"
+#include "locking.h"
+
+/* Registered with portmap */
+#define GF_MOUNTV3_PORT         38465
+#define GF_MOUNTV3_IOB          (2 * GF_UNIT_KB)
+#define GF_MOUNTV3_IOBPOOL      (GF_MOUNTV3_IOB * 50)
+
+#define GF_MOUNTV1_PORT         38466
+#define GF_MNT                  GF_NFS"-mount"
+
+extern rpcsvc_program_t *
+mnt3svc_init (xlator_t *nfsx);
+
+extern rpcsvc_program_t *
+mnt1svc_init (xlator_t *nfsx);
+
+/* Data structureused to store the list of mounts points currently
+ * in use by NFS clients.
+ */
+struct mountentry {
+        /* Links to mount3_state->mountlist.  */
+        struct list_head        mlist;
+
+        /* The export name */
+        char                    exname[MNTPATHLEN];
+        char                    hostname[MNTPATHLEN];
+};
+
+struct mount3_state {
+        xlator_t                *nfsx;
+
+        /* The buffers for all network IO are got from this pool. */
+        struct iobuf_pool       *iobpool;
+        xlator_list_t           *exports;
+
+        /* List of current mount points over all the exports from this
+         * server.
+         */
+        struct list_head        mountlist;
+
+        /* Used to protect the mountlist. */
+        gf_lock_t               mountlock;
+};
+#endif
diff --git a/xlators/nfs/server/src/nfs.c b/xlators/nfs/server/src/nfs.c
index ca6fda69c29..74937903612 100644
--- a/xlators/nfs/server/src/nfs.c
+++ b/xlators/nfs/server/src/nfs.c
@@ -36,6 +36,7 @@
 #include "logging.h"
 #include "nfs-fops.h"
 #include "inode.h"
+#include "mount3.h"
 
 /* Every NFS version must call this function with the init function
  * for its particular version.
@@ -134,8 +135,26 @@ err:
 int
 nfs_add_all_initiators (struct nfs_state *nfs)
 {
+        int     ret = 0;
+
         /* Add the initializers for all versions. */
-        return 0;
+        ret = nfs_add_initer (&nfs->versions, mnt3svc_init);
+        if (ret == -1) {
+                gf_log (GF_NFS, GF_LOG_ERROR, "Failed to add protocol"
+                        " initializer");
+                goto ret;
+        }
+
+        ret = nfs_add_initer (&nfs->versions, mnt1svc_init);
+        if (ret == -1) {
+                gf_log (GF_NFS, GF_LOG_ERROR, "Failed to add protocol"
+                        " initializer");
+                goto ret;
+        }
+
+        ret = 0;
+ret:
+        return ret;
 }
 
 
diff --git a/xlators/nfs/server/src/nfs3-fh.c b/xlators/nfs/server/src/nfs3-fh.c
new file mode 100644
index 00000000000..c7eb78fb378
--- /dev/null
+++ b/xlators/nfs/server/src/nfs3-fh.c
@@ -0,0 +1,271 @@
+/*
+  Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "rpcsvc.h"
+#include "dict.h"
+#include "xlator.h"
+#include "xdr-nfs3.h"
+#include "msg-nfs3.h"
+#include "iobuf.h"
+#include "nfs3-fh.h"
+#include "nfs-common.h"
+#include "iatt.h"
+
+
+int
+nfs3_fh_validate (struct nfs3_fh *fh)
+{
+	if (!fh)
+		return 0;
+
+	if (fh->ident[0] != GF_NFSFH_IDENT0)
+		return 0;
+
+	if (fh->ident[1] != GF_NFSFH_IDENT1)
+		return 0;
+
+        return 1;
+}
+
+
+xlator_t *
+nfs3_fh_to_xlator (xlator_list_t *cl, struct nfs3_fh *fh)
+{
+	if ((!cl) || (!fh))
+		return NULL;
+
+	return nfs_xlid_to_xlator (cl, fh->xlatorid);
+}
+
+void
+nfs3_fh_init (struct nfs3_fh *fh, struct iatt *buf)
+{
+        if ((!fh) || (!buf))
+                return;
+
+        fh->ident[0] = GF_NFSFH_IDENT0;
+        fh->ident[1] = GF_NFSFH_IDENT1;
+
+        fh->hashcount = 0;
+        fh->gen = buf->ia_gen;
+        fh->ino = buf->ia_ino;
+
+}
+
+
+struct nfs3_fh
+nfs3_fh_build_root_fh (xlator_list_t *cl, xlator_t *xl, struct iatt buf)
+{
+        struct nfs3_fh  fh = {{0}, };
+        if ((!cl) || (!xl))
+                return fh;
+
+        nfs3_fh_init (&fh, &buf);
+        fh.xlatorid = nfs_xlator_to_xlid (cl, xl);
+        fh.ino = 1;
+        fh.gen = 0;
+        return fh;
+}
+
+
+int
+nfs3_fh_is_root_fh (struct nfs3_fh *fh)
+{
+        if (!fh)
+                return 0;
+
+        if (fh->hashcount == 0)
+                return 1;
+
+        return 0;
+}
+
+
+nfs3_hash_entry_t
+nfs3_fh_hash_entry (ino_t ino, uint64_t gen)
+{
+        nfs3_hash_entry_t       hash = 0;
+        int                     shiftsize = 48;
+        nfs3_hash_entry_t       inomsb = 0;
+        nfs3_hash_entry_t       inolsb = 0;
+        nfs3_hash_entry_t       inols23b = 0;
+
+        nfs3_hash_entry_t       genmsb = 0;
+        nfs3_hash_entry_t       genlsb = 0;
+        nfs3_hash_entry_t       genls23b = 0;
+
+        hash = ino;
+        while (shiftsize != 0) {
+                hash ^= (ino >> shiftsize);
+                shiftsize -= 16;
+        }
+/*
+        gf_log ("FILEHANDLE", GF_LOG_TRACE, "INO %"PRIu64, ino);
+        gf_log ("FILEHANDLE",GF_LOG_TRACE, "PRI HASH %d", hash);
+*/
+        inomsb = (ino >> 56);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inomsb %d", inomsb);
+
+        inolsb = ((ino << 56) >> 56);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inolsb %d", inolsb);
+
+        inolsb = (inolsb << 8);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inolsb to inomsb %d", inolsb);
+        inols23b = ((ino << 40) >> 48);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inols23b %d", inols23b);
+
+        inols23b = (inols23b << 8);
+//        gf_log ("FILEHDNALE", GF_LOG_TRACE, "inols23b  %d", inols23b);
+
+        genmsb = (gen >> 56);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inomsb %d", inomsb);
+
+        genlsb = ((gen << 56) >> 56);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inolsb %d", inolsb);
+
+        genlsb = (genlsb << 8);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inolsb to inomsb %d", inolsb);
+
+        genls23b = ((gen << 40) >> 48);
+//        gf_log ("FILEHANDLE", GF_LOG_TRACE, "inols23b %d", inols23b);
+
+        genls23b = (genls23b << 8);
+//        gf_log ("FILEHDNALE", GF_LOG_TRACE, "inols23b  %d", inols23b);
+
+        hash ^= inolsb ^ inomsb ^ inols23b ^ genmsb ^ genlsb ^ genls23b;
+        return hash;
+
+}
+
+
+void
+nfs3_fh_to_str (struct nfs3_fh *fh, char *str)
+{
+        if ((!fh) || (!str))
+                return;
+
+        sprintf (str, "FH: hashcount %d, xlid %d, gen %"PRIu64", ino %"PRIu64,
+                 fh->hashcount, fh->xlatorid, fh->gen, fh->ino);
+}
+
+
+void
+nfs3_log_fh (struct nfs3_fh *fh)
+{
+//        int     x = 0;
+        if (!fh)
+                return;
+
+        gf_log ("nfs3-fh", GF_LOG_TRACE, "filehandle: hashcount %d, xlid %d, "
+                "gen %"PRIu64", ino %"PRIu64, fh->hashcount, fh->xlatorid,
+                fh->gen, fh->ino);
+/*
+        for (; x < fh->hashcount; ++x)
+                gf_log ("FILEHANDLE", GF_LOG_TRACE, "Hash %d: %d", x,
+                        fh->entryhash[x]);
+*/
+}
+
+
+int
+nfs3_fh_build_parent_fh (struct nfs3_fh *child, struct iatt *newstat,
+                         struct nfs3_fh *newfh)
+{
+        if ((!child) || (!newstat) || (!newfh))
+                return -1;
+
+        nfs3_fh_init (newfh, newstat);
+        newfh->xlatorid = child->xlatorid;
+        if ((newstat->ia_ino == 1) && (newstat->ia_gen == 0)) {
+                newfh->ino = 1;
+                newfh->gen = 0;
+                goto done;
+        }
+
+        newfh->hashcount = child->hashcount - 1;
+        memcpy (newfh->entryhash, child->entryhash,
+                newfh->hashcount * GF_NFSFH_ENTRYHASH_SIZE);
+
+done:
+//        nfs3_log_fh (newfh);
+
+        return 0;
+}
+
+
+
+int
+nfs3_fh_build_child_fh (struct nfs3_fh *parent, struct iatt *newstat,
+                        struct nfs3_fh *newfh)
+{
+        int             entry = 0;
+
+        if ((!parent) || (!newstat) || (!newfh))
+                return -1;
+
+        nfs3_fh_init (newfh, newstat);
+        newfh->xlatorid = parent->xlatorid;
+        if ((newstat->ia_ino == 1) && (newstat->ia_gen == 0)) {
+                newfh->ino = 1;
+                newfh->gen = 0;
+                goto done;
+        }
+
+        newfh->hashcount = parent->hashcount + 1;
+        memcpy (newfh->entryhash, parent->entryhash,
+                parent->hashcount * GF_NFSFH_ENTRYHASH_SIZE);
+        entry = newfh->hashcount - 1;
+        newfh->entryhash[entry] = nfs3_fh_hash_entry (parent->ino, parent->gen);
+
+done:
+//        nfs3_log_fh (newfh);
+
+        return 0;
+}
+
+
+uint32_t
+nfs3_fh_compute_size (struct nfs3_fh *fh)
+{
+        if (!fh)
+                return 0;
+
+        return (GF_NFSFH_STATIC_SIZE +
+                        (fh->hashcount * GF_NFSFH_ENTRYHASH_SIZE));
+}
+
+int
+nfs3_fh_hash_index_is_beyond (struct nfs3_fh *fh, int hashidx)
+{
+        if (!fh)
+                return 1;
+
+        if (fh->hashcount >= hashidx)
+                return 0;
+        else
+                return 1;
+
+        return 1;
+}
+
diff --git a/xlators/nfs/server/src/nfs3-fh.h b/xlators/nfs/server/src/nfs3-fh.h
new file mode 100644
index 00000000000..f526edf43b0
--- /dev/null
+++ b/xlators/nfs/server/src/nfs3-fh.h
@@ -0,0 +1,105 @@
+/*
+  Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _NFS_FH_H_
+#define _NFS_FH_H_
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "xlator.h"
+#include "xdr-nfs3.h"
+#include "iatt.h"
+#include <sys/types.h>
+
+/* BIG FAT WARNING: The file handle code is tightly coupled to NFSv3 file
+ * handles for now. This will change if and when we need v4. */
+#define GF_NFSFH_IDENT0         ':'
+#define GF_NFSFH_IDENT1         'O'
+#define GF_NFSFH_IDENT_SIZE     (sizeof(char) * 2)
+#define GF_NFSFH_STATIC_SIZE    (GF_NFSFH_IDENT_SIZE + sizeof (uint16_t) + sizeof (uint16_t) + sizeof (uint64_t) + sizeof(uint64_t))
+#define GF_NFSFH_MAX_HASH_BYTES (NFS3_FHSIZE - GF_NFSFH_STATIC_SIZE)
+
+/* Each hash element in the file handle is of 2 bytes thus giving
+ * us theoretically 65536 unique entries in a directory.
+ */
+typedef uint16_t                nfs3_hash_entry_t;
+#define GF_NFSFH_ENTRYHASH_SIZE (sizeof (nfs3_hash_entry_t))
+#define GF_NFSFH_MAXHASHES      ((int)(GF_NFSFH_MAX_HASH_BYTES / GF_NFSFH_ENTRYHASH_SIZE))
+
+/* ATTENTION: Change in size of the structure below should be reflected in the
+ * GF_NFSFH_STATIC_SIZE.
+ */
+struct nfs3_fh {
+
+        /* Used to ensure that a bunch of bytes are actually a GlusterFS NFS
+         * file handle. Should contain ":O"
+         */
+        char                    ident[2];
+
+        /* Number of file/ino hash elements that follow the ino. */
+        uint16_t                hashcount;
+
+        /* Basically, the position/index of an xlator among the children of
+         * the NFS xlator.
+         */
+        uint16_t                xlatorid;
+        uint64_t                gen;
+        uint64_t                ino;
+        nfs3_hash_entry_t       entryhash[GF_NFSFH_MAXHASHES];
+} __attribute__((__packed__));
+
+
+extern uint32_t
+nfs3_fh_compute_size (struct nfs3_fh *fh);
+
+extern int
+nfs3_fh_hash_index_is_beyond (struct nfs3_fh *fh, int hashidx);
+
+extern uint16_t
+nfs3_fh_hash_entry (ino_t ino, uint64_t gen);
+
+extern int
+nfs3_fh_validate (struct nfs3_fh *fh);
+
+extern xlator_t *
+nfs3_fh_to_xlator (xlator_list_t *cl, struct nfs3_fh *fh);
+
+extern struct nfs3_fh
+nfs3_fh_build_root_fh (xlator_list_t *cl, xlator_t *xl, struct iatt buf);
+
+extern int
+nfs3_fh_is_root_fh (struct nfs3_fh *fh);
+
+extern int
+nfs3_fh_build_child_fh (struct nfs3_fh *parent, struct iatt *newstat,
+                        struct nfs3_fh *newfh);
+
+extern void
+nfs3_log_fh (struct nfs3_fh *fh);
+
+extern void
+nfs3_fh_to_str (struct nfs3_fh *fh, char *str);
+
+extern int
+nfs3_fh_build_parent_fh (struct nfs3_fh *child, struct iatt *newstat,
+                         struct nfs3_fh *newfh);
+#endif