Merge branch 'for-3.7' of git://linux-nfs.org/~bfields/linux

Pull nfsd update from J Bruce Fields:
 "Another relatively quiet cycle.  There was some progress on my
  remaining 4.1 todo's, but a couple of them were just of the form
  "check that we do X correctly", so didn't have much affect on the
  code.

  Other than that, a bunch of cleanup and some bugfixes (including an
  annoying NFSv4.0 state leak and a busy-loop in the server that could
  cause it to peg the CPU without making progress)."

* 'for-3.7' of git://linux-nfs.org/~bfields/linux: (46 commits)
  UAPI: (Scripted) Disintegrate include/linux/sunrpc
  UAPI: (Scripted) Disintegrate include/linux/nfsd
  nfsd4: don't allow reclaims of expired clients
  nfsd4: remove redundant callback probe
  nfsd4: expire old client earlier
  nfsd4: separate session allocation and initialization
  nfsd4: clean up session allocation
  nfsd4: minor free_session cleanup
  nfsd4: new_conn_from_crses should only allocate
  nfsd4: separate connection allocation and initialization
  nfsd4: reject bad forechannel attrs earlier
  nfsd4: enforce per-client sessions/no-sessions distinction
  nfsd4: set cl_minorversion at create time
  nfsd4: don't pin clientids to pseudoflavors
  nfsd4: fix bind_conn_to_session xdr comment
  nfsd4: cast readlink() bug argument
  NFSD: pass null terminated buf to kstrtouint()
  nfsd: remove duplicate init in nfsd4_cb_recall
  nfsd4: eliminate redundant nfs4_free_stateid
  fs/nfsd/nfs4idmap.c: adjust inconsistent IS_ERR and PTR_ERR
  ...

3 files changed, 190 insertions, 204 deletions

diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
index bac973a31367..194d865fae72 100644
--- a/net/sunrpc/svc_xprt.c
+++ b/net/sunrpc/svc_xprt.c
@@ -208,6 +208,35 @@ static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
         return xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
 }
 
+/*
+ * svc_xprt_received conditionally queues the transport for processing
+ * by another thread. The caller must hold the XPT_BUSY bit and must
+ * not thereafter touch transport data.
+ *
+ * Note: XPT_DATA only gets cleared when a read-attempt finds no (or
+ * insufficient) data.
+ */
+static void svc_xprt_received(struct svc_xprt *xprt)
+{
+        BUG_ON(!test_bit(XPT_BUSY, &xprt->xpt_flags));
+        /* As soon as we clear busy, the xprt could be closed and
+         * 'put', so we need a reference to call svc_xprt_enqueue with:
+         */
+        svc_xprt_get(xprt);
+        clear_bit(XPT_BUSY, &xprt->xpt_flags);
+        svc_xprt_enqueue(xprt);
+        svc_xprt_put(xprt);
+}
+
+void svc_add_new_perm_xprt(struct svc_serv *serv, struct svc_xprt *new)
+{
+        clear_bit(XPT_TEMP, &new->xpt_flags);
+        spin_lock_bh(&serv->sv_lock);
+        list_add(&new->xpt_list, &serv->sv_permsocks);
+        spin_unlock_bh(&serv->sv_lock);
+        svc_xprt_received(new);
+}
+
 int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
                     struct net *net, const int family,
                     const unsigned short port, int flags)
@@ -232,13 +261,8 @@ int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
                         module_put(xcl->xcl_owner);
                         return PTR_ERR(newxprt);
                 }
-
-                clear_bit(XPT_TEMP, &newxprt->xpt_flags);
-                spin_lock_bh(&serv->sv_lock);
-                list_add(&newxprt->xpt_list, &serv->sv_permsocks);
-                spin_unlock_bh(&serv->sv_lock);
+                svc_add_new_perm_xprt(serv, newxprt);
                 newport = svc_xprt_local_port(newxprt);
-                clear_bit(XPT_BUSY, &newxprt->xpt_flags);
                 return newport;
         }
  err:
@@ -394,27 +418,6 @@ static struct svc_xprt *svc_xprt_dequeue(struct svc_pool *pool)
         return xprt;
 }
 
-/*
- * svc_xprt_received conditionally queues the transport for processing
- * by another thread. The caller must hold the XPT_BUSY bit and must
- * not thereafter touch transport data.
- *
- * Note: XPT_DATA only gets cleared when a read-attempt finds no (or
- * insufficient) data.
- */
-void svc_xprt_received(struct svc_xprt *xprt)
-{
-        BUG_ON(!test_bit(XPT_BUSY, &xprt->xpt_flags));
-        /* As soon as we clear busy, the xprt could be closed and
-         * 'put', so we need a reference to call svc_xprt_enqueue with:
-         */
-        svc_xprt_get(xprt);
-        clear_bit(XPT_BUSY, &xprt->xpt_flags);
-        svc_xprt_enqueue(xprt);
-        svc_xprt_put(xprt);
-}
-EXPORT_SYMBOL_GPL(svc_xprt_received);
-
 /**
  * svc_reserve - change the space reserved for the reply to a request.
  * @rqstp:  The request in question
@@ -565,33 +568,12 @@ static void svc_check_conn_limits(struct svc_serv *serv)
         }
 }
 
-/*
- * Receive the next request on any transport.  This code is carefully
- * organised not to touch any cachelines in the shared svc_serv
- * structure, only cachelines in the local svc_pool.
- */
-int svc_recv(struct svc_rqst *rqstp, long timeout)
+int svc_alloc_arg(struct svc_rqst *rqstp)
 {
-        struct svc_xprt         *xprt = NULL;
-        struct svc_serv         *serv = rqstp->rq_server;
-        struct svc_pool         *pool = rqstp->rq_pool;
-        int                     len, i;
-        int                     pages;
-        struct xdr_buf          *arg;
-        DECLARE_WAITQUEUE(wait, current);
-        long                    time_left;
-
-        dprintk("svc: server %p waiting for data (to = %ld)\n",
-                rqstp, timeout);
-
-        if (rqstp->rq_xprt)
-                printk(KERN_ERR
-                        "svc_recv: service %p, transport not NULL!\n",
-                         rqstp);
-        if (waitqueue_active(&rqstp->rq_wait))
-                printk(KERN_ERR
-                        "svc_recv: service %p, wait queue active!\n",
-                         rqstp);
+        struct svc_serv *serv = rqstp->rq_server;
+        struct xdr_buf *arg;
+        int pages;
+        int i;
 
         /* now allocate needed pages.  If we get a failure, sleep briefly */
         pages = (serv->sv_max_mesg + PAGE_SIZE) / PAGE_SIZE;
@@ -621,11 +603,15 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
         arg->page_len = (pages-2)*PAGE_SIZE;
         arg->len = (pages-1)*PAGE_SIZE;
         arg->tail[0].iov_len = 0;
+        return 0;
+}
 
-        try_to_freeze();
-        cond_resched();
-        if (signalled() || kthread_should_stop())
-                return -EINTR;
+struct svc_xprt *svc_get_next_xprt(struct svc_rqst *rqstp, long timeout)
+{
+        struct svc_xprt *xprt;
+        struct svc_pool         *pool = rqstp->rq_pool;
+        DECLARE_WAITQUEUE(wait, current);
+        long                    time_left;
 
         /* Normally we will wait up to 5 seconds for any required
          * cache information to be provided.
@@ -663,7 +649,7 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
                 if (kthread_should_stop()) {
                         set_current_state(TASK_RUNNING);
                         spin_unlock_bh(&pool->sp_lock);
-                        return -EINTR;
+                        return ERR_PTR(-EINTR);
                 }
 
                 add_wait_queue(&rqstp->rq_wait, &wait);
@@ -684,48 +670,58 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
                         spin_unlock_bh(&pool->sp_lock);
                         dprintk("svc: server %p, no data yet\n", rqstp);
                         if (signalled() || kthread_should_stop())
-                                return -EINTR;
+                                return ERR_PTR(-EINTR);
                         else
-                                return -EAGAIN;
+                                return ERR_PTR(-EAGAIN);
                 }
         }
         spin_unlock_bh(&pool->sp_lock);
+        return xprt;
+}
+
+void svc_add_new_temp_xprt(struct svc_serv *serv, struct svc_xprt *newxpt)
+{
+        spin_lock_bh(&serv->sv_lock);
+        set_bit(XPT_TEMP, &newxpt->xpt_flags);
+        list_add(&newxpt->xpt_list, &serv->sv_tempsocks);
+        serv->sv_tmpcnt++;
+        if (serv->sv_temptimer.function == NULL) {
+                /* setup timer to age temp transports */
+                setup_timer(&serv->sv_temptimer, svc_age_temp_xprts,
+                            (unsigned long)serv);
+                mod_timer(&serv->sv_temptimer,
+                          jiffies + svc_conn_age_period * HZ);
+        }
+        spin_unlock_bh(&serv->sv_lock);
+        svc_xprt_received(newxpt);
+}
+
+static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
+{
+        struct svc_serv *serv = rqstp->rq_server;
+        int len = 0;
 
-        len = 0;
         if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
                 dprintk("svc_recv: found XPT_CLOSE\n");
                 svc_delete_xprt(xprt);
                 /* Leave XPT_BUSY set on the dead xprt: */
-                goto out;
+                return 0;
         }
         if (test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
                 struct svc_xprt *newxpt;
+                /*
+                 * We know this module_get will succeed because the
+                 * listener holds a reference too
+                 */
+                __module_get(xprt->xpt_class->xcl_owner);
+                svc_check_conn_limits(xprt->xpt_server);
                 newxpt = xprt->xpt_ops->xpo_accept(xprt);
-                if (newxpt) {
-                        /*
-                         * We know this module_get will succeed because the
-                         * listener holds a reference too
-                         */
-                        __module_get(newxpt->xpt_class->xcl_owner);
-                        svc_check_conn_limits(xprt->xpt_server);
-                        spin_lock_bh(&serv->sv_lock);
-                        set_bit(XPT_TEMP, &newxpt->xpt_flags);
-                        list_add(&newxpt->xpt_list, &serv->sv_tempsocks);
-                        serv->sv_tmpcnt++;
-                        if (serv->sv_temptimer.function == NULL) {
-                                /* setup timer to age temp transports */
-                                setup_timer(&serv->sv_temptimer,
-                                            svc_age_temp_xprts,
-                                            (unsigned long)serv);
-                                mod_timer(&serv->sv_temptimer,
-                                          jiffies + svc_conn_age_period * HZ);
-                        }
-                        spin_unlock_bh(&serv->sv_lock);
-                        svc_xprt_received(newxpt);
-                }
+                if (newxpt)
+                        svc_add_new_temp_xprt(serv, newxpt);
         } else if (xprt->xpt_ops->xpo_has_wspace(xprt)) {
+                /* XPT_DATA|XPT_DEFERRED case: */
                 dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
-                        rqstp, pool->sp_id, xprt,
+                        rqstp, rqstp->rq_pool->sp_id, xprt,
                         atomic_read(&xprt->xpt_ref.refcount));
                 rqstp->rq_deferred = svc_deferred_dequeue(xprt);
                 if (rqstp->rq_deferred)
@@ -736,10 +732,51 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
                 rqstp->rq_reserved = serv->sv_max_mesg;
                 atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
         }
+        /* clear XPT_BUSY: */
         svc_xprt_received(xprt);
+        return len;
+}
+
+/*
+ * Receive the next request on any transport.  This code is carefully
+ * organised not to touch any cachelines in the shared svc_serv
+ * structure, only cachelines in the local svc_pool.
+ */
+int svc_recv(struct svc_rqst *rqstp, long timeout)
+{
+        struct svc_xprt         *xprt = NULL;
+        struct svc_serv         *serv = rqstp->rq_server;
+        int                     len, err;
+
+        dprintk("svc: server %p waiting for data (to = %ld)\n",
+                rqstp, timeout);
+
+        if (rqstp->rq_xprt)
+                printk(KERN_ERR
+                        "svc_recv: service %p, transport not NULL!\n",
+                         rqstp);
+        if (waitqueue_active(&rqstp->rq_wait))
+                printk(KERN_ERR
+                        "svc_recv: service %p, wait queue active!\n",
+                         rqstp);
+
+        err = svc_alloc_arg(rqstp);
+        if (err)
+                return err;
+
+        try_to_freeze();
+        cond_resched();
+        if (signalled() || kthread_should_stop())
+                return -EINTR;
+
+        xprt = svc_get_next_xprt(rqstp, timeout);
+        if (IS_ERR(xprt))
+                return PTR_ERR(xprt);
+
+        len = svc_handle_xprt(rqstp, xprt);
 
         /* No data, incomplete (TCP) read, or accept() */
-        if (len == 0 || len == -EAGAIN)
+        if (len <= 0)
                 goto out;
 
         clear_bit(XPT_OLD, &xprt->xpt_flags);
@@ -917,16 +954,18 @@ void svc_close_xprt(struct svc_xprt *xprt)
 }
 EXPORT_SYMBOL_GPL(svc_close_xprt);
 
-static void svc_close_list(struct list_head *xprt_list, struct net *net)
+static void svc_close_list(struct svc_serv *serv, struct list_head *xprt_list, struct net *net)
 {
         struct svc_xprt *xprt;
 
+        spin_lock(&serv->sv_lock);
         list_for_each_entry(xprt, xprt_list, xpt_list) {
                 if (xprt->xpt_net != net)
                         continue;
                 set_bit(XPT_CLOSE, &xprt->xpt_flags);
                 set_bit(XPT_BUSY, &xprt->xpt_flags);
         }
+        spin_unlock(&serv->sv_lock);
 }
 
 static void svc_clear_pools(struct svc_serv *serv, struct net *net)
@@ -949,24 +988,28 @@ static void svc_clear_pools(struct svc_serv *serv, struct net *net)
         }
 }
 
-static void svc_clear_list(struct list_head *xprt_list, struct net *net)
+static void svc_clear_list(struct svc_serv *serv, struct list_head *xprt_list, struct net *net)
 {
         struct svc_xprt *xprt;
         struct svc_xprt *tmp;
+        LIST_HEAD(victims);
 
+        spin_lock(&serv->sv_lock);
         list_for_each_entry_safe(xprt, tmp, xprt_list, xpt_list) {
                 if (xprt->xpt_net != net)
                         continue;
-                svc_delete_xprt(xprt);
+                list_move(&xprt->xpt_list, &victims);
         }
-        list_for_each_entry(xprt, xprt_list, xpt_list)
-                BUG_ON(xprt->xpt_net == net);
+        spin_unlock(&serv->sv_lock);
+
+        list_for_each_entry_safe(xprt, tmp, &victims, xpt_list)
+                svc_delete_xprt(xprt);
 }
 
 void svc_close_net(struct svc_serv *serv, struct net *net)
 {
-        svc_close_list(&serv->sv_tempsocks, net);
-        svc_close_list(&serv->sv_permsocks, net);
+        svc_close_list(serv, &serv->sv_tempsocks, net);
+        svc_close_list(serv, &serv->sv_permsocks, net);
 
         svc_clear_pools(serv, net);
         /*
@@ -974,8 +1017,8 @@ void svc_close_net(struct svc_serv *serv, struct net *net)
          * svc_xprt_enqueue will not add new entries without taking the
          * sp_lock and checking XPT_BUSY.
          */
-        svc_clear_list(&serv->sv_tempsocks, net);
-        svc_clear_list(&serv->sv_permsocks, net);
+        svc_clear_list(serv, &serv->sv_tempsocks, net);
+        svc_clear_list(serv, &serv->sv_permsocks, net);
 }
 
 /*
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 998aa8c1807c..03827cef1fa7 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -59,7 +59,7 @@
 
 
 static struct svc_sock *svc_setup_socket(struct svc_serv *, struct socket *,
-                                         int *errp, int flags);
+                                         int flags);
 static void             svc_udp_data_ready(struct sock *, int);
 static int              svc_udp_recvfrom(struct svc_rqst *);
 static int              svc_udp_sendto(struct svc_rqst *);
@@ -305,57 +305,6 @@ static int svc_one_sock_name(struct svc_sock *svsk, char *buf, int remaining)
         return len;
 }
 
-/**
- * svc_sock_names - construct a list of listener names in a string
- * @serv: pointer to RPC service
- * @buf: pointer to a buffer to fill in with socket names
- * @buflen: size of the buffer to be filled
- * @toclose: pointer to '\0'-terminated C string containing the name
- *              of a listener to be closed
- *
- * Fills in @buf with a '\n'-separated list of names of listener
- * sockets.  If @toclose is not NULL, the socket named by @toclose
- * is closed, and is not included in the output list.
- *
- * Returns positive length of the socket name string, or a negative
- * errno value on error.
- */
-int svc_sock_names(struct svc_serv *serv, char *buf, const size_t buflen,
-                   const char *toclose)
-{
-        struct svc_sock *svsk, *closesk = NULL;
-        int len = 0;
-
-        if (!serv)
-                return 0;
-
-        spin_lock_bh(&serv->sv_lock);
-        list_for_each_entry(svsk, &serv->sv_permsocks, sk_xprt.xpt_list) {
-                int onelen = svc_one_sock_name(svsk, buf + len, buflen - len);
-                if (onelen < 0) {
-                        len = onelen;
-                        break;
-                }
-                if (toclose && strcmp(toclose, buf + len) == 0) {
-                        closesk = svsk;
-                        svc_xprt_get(&closesk->sk_xprt);
-                } else
-                        len += onelen;
-        }
-        spin_unlock_bh(&serv->sv_lock);
-
-        if (closesk) {
-                /* Should unregister with portmap, but you cannot
-                 * unregister just one protocol...
-                 */
-                svc_close_xprt(&closesk->sk_xprt);
-                svc_xprt_put(&closesk->sk_xprt);
-        } else if (toclose)
-                return -ENOENT;
-        return len;
-}
-EXPORT_SYMBOL_GPL(svc_sock_names);
-
 /*
  * Check input queue length
  */
@@ -598,11 +547,9 @@ static int svc_udp_recvfrom(struct svc_rqst *rqstp)
                         dprintk("svc: recvfrom returned error %d\n", -err);
                         set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
                 }
-                return -EAGAIN;
+                return 0;
         }
         len = svc_addr_len(svc_addr(rqstp));
-        if (len == 0)
-                return -EAFNOSUPPORT;
         rqstp->rq_addrlen = len;
         if (skb->tstamp.tv64 == 0) {
                 skb->tstamp = ktime_get_real();
@@ -620,10 +567,7 @@ static int svc_udp_recvfrom(struct svc_rqst *rqstp)
         if (!svc_udp_get_dest_address(rqstp, cmh)) {
                 net_warn_ratelimited("svc: received unknown control message %d/%d; dropping RPC reply datagram\n",
                                      cmh->cmsg_level, cmh->cmsg_type);
-out_free:
-                trace_kfree_skb(skb, svc_udp_recvfrom);
-                skb_free_datagram_locked(svsk->sk_sk, skb);
-                return 0;
+                goto out_free;
         }
         rqstp->rq_daddrlen = svc_addr_len(svc_daddr(rqstp));
 
@@ -662,6 +606,10 @@ out_free:
                 serv->sv_stats->netudpcnt++;
 
         return len;
+out_free:
+        trace_kfree_skb(skb, svc_udp_recvfrom);
+        skb_free_datagram_locked(svsk->sk_sk, skb);
+        return 0;
 }
 
 static int
@@ -900,8 +848,9 @@ static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt)
          */
         newsock->sk->sk_sndtimeo = HZ*30;
 
-        if (!(newsvsk = svc_setup_socket(serv, newsock, &err,
-                                 (SVC_SOCK_ANONYMOUS | SVC_SOCK_TEMPORARY))))
+        newsvsk = svc_setup_socket(serv, newsock,
+                                 (SVC_SOCK_ANONYMOUS | SVC_SOCK_TEMPORARY));
+        if (IS_ERR(newsvsk))
                 goto failed;
         svc_xprt_set_remote(&newsvsk->sk_xprt, sin, slen);
         err = kernel_getsockname(newsock, sin, &slen);
@@ -1174,13 +1123,13 @@ error:
         if (len != -EAGAIN)
                 goto err_other;
         dprintk("RPC: TCP recvfrom got EAGAIN\n");
-        return -EAGAIN;
+        return 0;
 err_other:
         printk(KERN_NOTICE "%s: recvfrom returned errno %d\n",
                svsk->sk_xprt.xpt_server->sv_name, -len);
         set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
 err_noclose:
-        return -EAGAIN; /* record not complete */
+        return 0;       /* record not complete */
 }
 
 /*
@@ -1383,29 +1332,29 @@ EXPORT_SYMBOL_GPL(svc_sock_update_bufs);
  */
 static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
                                                 struct socket *sock,
-                                                int *errp, int flags)
+                                                int flags)
 {
         struct svc_sock *svsk;
         struct sock     *inet;
         int             pmap_register = !(flags & SVC_SOCK_ANONYMOUS);
+        int             err = 0;
 
         dprintk("svc: svc_setup_socket %p\n", sock);
-        if (!(svsk = kzalloc(sizeof(*svsk), GFP_KERNEL))) {
-                *errp = -ENOMEM;
-                return NULL;
-        }
+        svsk = kzalloc(sizeof(*svsk), GFP_KERNEL);
+        if (!svsk)
+                return ERR_PTR(-ENOMEM);
 
         inet = sock->sk;
 
         /* Register socket with portmapper */
-        if (*errp >= 0 && pmap_register)
-                *errp = svc_register(serv, sock_net(sock->sk), inet->sk_family,
+        if (pmap_register)
+                err = svc_register(serv, sock_net(sock->sk), inet->sk_family,
                                      inet->sk_protocol,
                                      ntohs(inet_sk(inet)->inet_sport));
 
-        if (*errp < 0) {
+        if (err < 0) {
                 kfree(svsk);
-                return NULL;
+                return ERR_PTR(err);
         }
 
         inet->sk_user_data = svsk;
@@ -1450,42 +1399,38 @@ int svc_addsock(struct svc_serv *serv, const int fd, char *name_return,
         int err = 0;
         struct socket *so = sockfd_lookup(fd, &err);
         struct svc_sock *svsk = NULL;
+        struct sockaddr_storage addr;
+        struct sockaddr *sin = (struct sockaddr *)&addr;
+        int salen;
 
         if (!so)
                 return err;
+        err = -EAFNOSUPPORT;
         if ((so->sk->sk_family != PF_INET) && (so->sk->sk_family != PF_INET6))
-                err =  -EAFNOSUPPORT;
-        else if (so->sk->sk_protocol != IPPROTO_TCP &&
+                goto out;
+        err =  -EPROTONOSUPPORT;
+        if (so->sk->sk_protocol != IPPROTO_TCP &&
             so->sk->sk_protocol != IPPROTO_UDP)
-                err =  -EPROTONOSUPPORT;
-        else if (so->state > SS_UNCONNECTED)
-                err = -EISCONN;
-        else {
-                if (!try_module_get(THIS_MODULE))
-                        err = -ENOENT;
-                else
-                        svsk = svc_setup_socket(serv, so, &err,
-                                                SVC_SOCK_DEFAULTS);
-                if (svsk) {
-                        struct sockaddr_storage addr;
-                        struct sockaddr *sin = (struct sockaddr *)&addr;
-                        int salen;
-                        if (kernel_getsockname(svsk->sk_sock, sin, &salen) == 0)
-                                svc_xprt_set_local(&svsk->sk_xprt, sin, salen);
-                        clear_bit(XPT_TEMP, &svsk->sk_xprt.xpt_flags);
-                        spin_lock_bh(&serv->sv_lock);
-                        list_add(&svsk->sk_xprt.xpt_list, &serv->sv_permsocks);
-                        spin_unlock_bh(&serv->sv_lock);
-                        svc_xprt_received(&svsk->sk_xprt);
-                        err = 0;
-                } else
-                        module_put(THIS_MODULE);
-        }
-        if (err) {
-                sockfd_put(so);
-                return err;
+                goto out;
+        err = -EISCONN;
+        if (so->state > SS_UNCONNECTED)
+                goto out;
+        err = -ENOENT;
+        if (!try_module_get(THIS_MODULE))
+                goto out;
+        svsk = svc_setup_socket(serv, so, SVC_SOCK_DEFAULTS);
+        if (IS_ERR(svsk)) {
+                module_put(THIS_MODULE);
+                err = PTR_ERR(svsk);
+                goto out;
         }
+        if (kernel_getsockname(svsk->sk_sock, sin, &salen) == 0)
+                svc_xprt_set_local(&svsk->sk_xprt, sin, salen);
+        svc_add_new_perm_xprt(serv, &svsk->sk_xprt);
         return svc_one_sock_name(svsk, name_return, len);
+out:
+        sockfd_put(so);
+        return err;
 }
 EXPORT_SYMBOL_GPL(svc_addsock);
 
@@ -1563,11 +1508,13 @@ static struct svc_xprt *svc_create_socket(struct svc_serv *serv,
                         goto bummer;
         }
 
-        if ((svsk = svc_setup_socket(serv, sock, &error, flags)) != NULL) {
-                svc_xprt_set_local(&svsk->sk_xprt, newsin, newlen);
-                return (struct svc_xprt *)svsk;
+        svsk = svc_setup_socket(serv, sock, flags);
+        if (IS_ERR(svsk)) {
+                error = PTR_ERR(svsk);
+                goto bummer;
         }
-
+        svc_xprt_set_local(&svsk->sk_xprt, newsin, newlen);
+        return (struct svc_xprt *)svsk;
 bummer:
         dprintk("svc: svc_create_socket error = %d\n", -error);
         sock_release(sock);
diff --git a/net/sunrpc/xprtrdma/svc_rdma_transport.c b/net/sunrpc/xprtrdma/svc_rdma_transport.c
index 73b428bef598..62e4f9bcc387 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_transport.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_transport.c
@@ -578,10 +578,6 @@ static void handle_connect_req(struct rdma_cm_id *new_cma_id, size_t client_ird)
         list_add_tail(&newxprt->sc_accept_q, &listen_xprt->sc_accept_q);
         spin_unlock_bh(&listen_xprt->sc_lock);
 
-        /*
-         * Can't use svc_xprt_received here because we are not on a
-         * rqstp thread
-        */
         set_bit(XPT_CONN, &listen_xprt->sc_xprt.xpt_flags);
         svc_xprt_enqueue(&listen_xprt->sc_xprt);
 }