5 files changed, 161 insertions, 86 deletions

diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index c448c7f6fde2..3c23760c5827 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -156,7 +156,8 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
 
         /* Get the DATA. Size must match skb_add_mtu(). */
         size = SKB_DATA_ALIGN(size);
-        data = ____kmalloc(size + sizeof(struct skb_shared_info), gfp_mask);
+        data = kmalloc_track_caller(size + sizeof(struct skb_shared_info),
+                        gfp_mask);
         if (!data)
                 goto nodata;
 
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 638c0b576203..447d9aef4605 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -903,9 +903,9 @@ out_seq:
 struct gss_svc_data {
         /* decoded gss client cred: */
         struct rpc_gss_wire_cred        clcred;
-        /* pointer to the beginning of the procedure-specific results,
-         * which may be encrypted/checksummed in svcauth_gss_release: */
-        __be32                          *body_start;
+        /* save a pointer to the beginning of the encoded verifier,
+         * for use in encryption/checksumming in svcauth_gss_release: */
+        __be32                          *verf_start;
         struct rsc                      *rsci;
 };
 
@@ -968,7 +968,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
         if (!svcdata)
                 goto auth_err;
         rqstp->rq_auth_data = svcdata;
-        svcdata->body_start = NULL;
+        svcdata->verf_start = NULL;
         svcdata->rsci = NULL;
         gc = &svcdata->clcred;
 
@@ -1097,6 +1097,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
                 goto complete;
         case RPC_GSS_PROC_DATA:
                 *authp = rpcsec_gsserr_ctxproblem;
+                svcdata->verf_start = resv->iov_base + resv->iov_len;
                 if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
                         goto auth_err;
                 rqstp->rq_cred = rsci->cred;
@@ -1110,7 +1111,6 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
                                         gc->gc_seq, rsci->mechctx))
                                 goto auth_err;
                         /* placeholders for length and seq. number: */
-                        svcdata->body_start = resv->iov_base + resv->iov_len;
                         svc_putnl(resv, 0);
                         svc_putnl(resv, 0);
                         break;
@@ -1119,7 +1119,6 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
                                         gc->gc_seq, rsci->mechctx))
                                 goto auth_err;
                         /* placeholders for length and seq. number: */
-                        svcdata->body_start = resv->iov_base + resv->iov_len;
                         svc_putnl(resv, 0);
                         svc_putnl(resv, 0);
                         break;
@@ -1147,6 +1146,32 @@ out:
         return ret;
 }
 
+u32 *
+svcauth_gss_prepare_to_wrap(struct xdr_buf *resbuf, struct gss_svc_data *gsd)
+{
+        u32 *p, verf_len;
+
+        p = gsd->verf_start;
+        gsd->verf_start = NULL;
+
+        /* If the reply stat is nonzero, don't wrap: */
+        if (*(p-1) != rpc_success)
+                return NULL;
+        /* Skip the verifier: */
+        p += 1;
+        verf_len = ntohl(*p++);
+        p += XDR_QUADLEN(verf_len);
+        /* move accept_stat to right place: */
+        memcpy(p, p + 2, 4);
+        /* Also don't wrap if the accept stat is nonzero: */
+        if (*p != rpc_success) {
+                resbuf->head[0].iov_len -= 2 * 4;
+                return NULL;
+        }
+        p++;
+        return p;
+}
+
 static inline int
 svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
 {
@@ -1160,17 +1185,9 @@ svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
         int integ_offset, integ_len;
         int stat = -EINVAL;
 
-        p = gsd->body_start;
-        gsd->body_start = NULL;
-        /* move accept_stat to right place: */
-        memcpy(p, p + 2, 4);
-        /* Don't wrap in failure case: */
-        /* Counting on not getting here if call was not even accepted! */
-        if (*p != rpc_success) {
-                resbuf->head[0].iov_len -= 2 * 4;
+        p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
+        if (p == NULL)
                 goto out;
-        }
-        p++;
         integ_offset = (u8 *)(p + 1) - (u8 *)resbuf->head[0].iov_base;
         integ_len = resbuf->len - integ_offset;
         BUG_ON(integ_len % 4);
@@ -1191,7 +1208,6 @@ svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
                 resbuf->tail[0].iov_base = resbuf->head[0].iov_base
                                                 + resbuf->head[0].iov_len;
                 resbuf->tail[0].iov_len = 0;
-                rqstp->rq_restailpage = 0;
                 resv = &resbuf->tail[0];
         } else {
                 resv = &resbuf->tail[0];
@@ -1223,24 +1239,16 @@ svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
         int offset;
         int pad;
 
-        p = gsd->body_start;
-        gsd->body_start = NULL;
-        /* move accept_stat to right place: */
-        memcpy(p, p + 2, 4);
-        /* Don't wrap in failure case: */
-        /* Counting on not getting here if call was not even accepted! */
-        if (*p != rpc_success) {
-                resbuf->head[0].iov_len -= 2 * 4;
+        p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
+        if (p == NULL)
                 return 0;
-        }
-        p++;
         len = p++;
         offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base;
         *p++ = htonl(gc->gc_seq);
         inpages = resbuf->pages;
         /* XXX: Would be better to write some xdr helper functions for
          * nfs{2,3,4}xdr.c that place the data right, instead of copying: */
-        if (resbuf->tail[0].iov_base && rqstp->rq_restailpage == 0) {
+        if (resbuf->tail[0].iov_base) {
                 BUG_ON(resbuf->tail[0].iov_base >= resbuf->head[0].iov_base
                                                         + PAGE_SIZE);
                 BUG_ON(resbuf->tail[0].iov_base < resbuf->head[0].iov_base);
@@ -1258,7 +1266,6 @@ svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
                 resbuf->tail[0].iov_base = resbuf->head[0].iov_base
                         + resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE;
                 resbuf->tail[0].iov_len = 0;
-                rqstp->rq_restailpage = 0;
         }
         if (gss_wrap(gsd->rsci->mechctx, offset, resbuf, inpages))
                 return -ENOMEM;
@@ -1282,7 +1289,7 @@ svcauth_gss_release(struct svc_rqst *rqstp)
         if (gc->gc_proc != RPC_GSS_PROC_DATA)
                 goto out;
         /* Release can be called twice, but we only wrap once. */
-        if (gsd->body_start == NULL)
+        if (gsd->verf_start == NULL)
                 goto out;
         /* normally not set till svc_send, but we need it here: */
         /* XXX: what for?  Do we mess it up the moment we call svc_putu32
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index a99e67b164c1..c2c8bb20d07f 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -417,18 +417,15 @@ svc_init_buffer(struct svc_rqst *rqstp, unsigned int size)
         if (size > RPCSVC_MAXPAYLOAD)
                 size = RPCSVC_MAXPAYLOAD;
         pages = 2 + (size+ PAGE_SIZE -1) / PAGE_SIZE;
-        rqstp->rq_argused = 0;
-        rqstp->rq_resused = 0;
         arghi = 0;
         BUG_ON(pages > RPCSVC_MAXPAGES);
         while (pages) {
                 struct page *p = alloc_page(GFP_KERNEL);
                 if (!p)
                         break;
-                rqstp->rq_argpages[arghi++] = p;
+                rqstp->rq_pages[arghi++] = p;
                 pages--;
         }
-        rqstp->rq_arghi = arghi;
         return ! pages;
 }
 
@@ -438,14 +435,10 @@ svc_init_buffer(struct svc_rqst *rqstp, unsigned int size)
 static void
 svc_release_buffer(struct svc_rqst *rqstp)
 {
-        while (rqstp->rq_arghi)
-                put_page(rqstp->rq_argpages[--rqstp->rq_arghi]);
-        while (rqstp->rq_resused) {
-                if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
-                        continue;
-                put_page(rqstp->rq_respages[rqstp->rq_resused]);
-        }
-        rqstp->rq_argused = 0;
+        int i;
+        for (i=0; i<ARRAY_SIZE(rqstp->rq_pages); i++)
+                if (rqstp->rq_pages[i])
+                        put_page(rqstp->rq_pages[i]);
 }
 
 /*
@@ -651,23 +644,32 @@ svc_register(struct svc_serv *serv, int proto, unsigned short port)
         unsigned long           flags;
         int                     i, error = 0, dummy;
 
-        progp = serv->sv_program;
-
-        dprintk("RPC: svc_register(%s, %s, %d)\n",
-                progp->pg_name, proto == IPPROTO_UDP? "udp" : "tcp", port);
-
         if (!port)
                 clear_thread_flag(TIF_SIGPENDING);
 
-        for (i = 0; i < progp->pg_nvers; i++) {
-                if (progp->pg_vers[i] == NULL)
-                        continue;
-                error = rpc_register(progp->pg_prog, i, proto, port, &dummy);
-                if (error < 0)
-                        break;
-                if (port && !dummy) {
-                        error = -EACCES;
-                        break;
+        for (progp = serv->sv_program; progp; progp = progp->pg_next) {
+                for (i = 0; i < progp->pg_nvers; i++) {
+                        if (progp->pg_vers[i] == NULL)
+                                continue;
+
+                        dprintk("RPC: svc_register(%s, %s, %d, %d)%s\n",
+                                        progp->pg_name,
+                                        proto == IPPROTO_UDP?  "udp" : "tcp",
+                                        port,
+                                        i,
+                                        progp->pg_vers[i]->vs_hidden?
+                                                " (but not telling portmap)" : "");
+
+                        if (progp->pg_vers[i]->vs_hidden)
+                                continue;
+
+                        error = rpc_register(progp->pg_prog, i, proto, port, &dummy);
+                        if (error < 0)
+                                break;
+                        if (port && !dummy) {
+                                error = -EACCES;
+                                break;
+                        }
                 }
         }
 
@@ -697,7 +699,7 @@ svc_process(struct svc_rqst *rqstp)
         u32                     dir, prog, vers, proc;
         __be32                  auth_stat, rpc_stat;
         int                     auth_res;
-        __be32                  *accept_statp;
+        __be32                  *reply_statp;
 
         rpc_stat = rpc_success;
 
@@ -707,10 +709,10 @@ svc_process(struct svc_rqst *rqstp)
         /* setup response xdr_buf.
          * Initially it has just one page 
          */
-        svc_take_page(rqstp); /* must succeed */
+        rqstp->rq_resused = 1;
         resv->iov_base = page_address(rqstp->rq_respages[0]);
         resv->iov_len = 0;
-        rqstp->rq_res.pages = rqstp->rq_respages+1;
+        rqstp->rq_res.pages = rqstp->rq_respages + 1;
         rqstp->rq_res.len = 0;
         rqstp->rq_res.page_base = 0;
         rqstp->rq_res.page_len = 0;
@@ -738,7 +740,7 @@ svc_process(struct svc_rqst *rqstp)
                 goto err_bad_rpc;
 
         /* Save position in case we later decide to reject: */
-        accept_statp = resv->iov_base + resv->iov_len;
+        reply_statp = resv->iov_base + resv->iov_len;
 
         svc_putnl(resv, 0);             /* ACCEPT */
 
@@ -886,7 +888,7 @@ err_bad_auth:
         dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat));
         serv->sv_stats->rpcbadauth++;
         /* Restore write pointer to location of accept status: */
-        xdr_ressize_check(rqstp, accept_statp);
+        xdr_ressize_check(rqstp, reply_statp);
         svc_putnl(resv, 1);     /* REJECT */
         svc_putnl(resv, 1);     /* AUTH_ERROR */
         svc_putnl(resv, ntohl(auth_stat));      /* status */
@@ -926,3 +928,18 @@ err_bad:
         svc_putnl(resv, ntohl(rpc_stat));
         goto sendit;
 }
+
+/*
+ * Return (transport-specific) limit on the rpc payload.
+ */
+u32 svc_max_payload(const struct svc_rqst *rqstp)
+{
+        int max = RPCSVC_MAXPAYLOAD_TCP;
+
+        if (rqstp->rq_sock->sk_sock->type == SOCK_DGRAM)
+                max = RPCSVC_MAXPAYLOAD_UDP;
+        if (rqstp->rq_server->sv_bufsz < max)
+                max = rqstp->rq_server->sv_bufsz;
+        return max;
+}
+EXPORT_SYMBOL_GPL(svc_max_payload);
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 40d41a2831d7..e1bd933629fe 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -9,6 +9,7 @@
 #include <linux/seq_file.h>
 #include <linux/hash.h>
 #include <linux/string.h>
+#include <net/sock.h>
 
 #define RPCDBG_FACILITY RPCDBG_AUTH
 
@@ -375,6 +376,44 @@ void svcauth_unix_purge(void)
         cache_purge(&ip_map_cache);
 }
 
+static inline struct ip_map *
+ip_map_cached_get(struct svc_rqst *rqstp)
+{
+        struct ip_map *ipm = rqstp->rq_sock->sk_info_authunix;
+        if (ipm != NULL) {
+                if (!cache_valid(&ipm->h)) {
+                        /*
+                         * The entry has been invalidated since it was
+                         * remembered, e.g. by a second mount from the
+                         * same IP address.
+                         */
+                        rqstp->rq_sock->sk_info_authunix = NULL;
+                        cache_put(&ipm->h, &ip_map_cache);
+                        return NULL;
+                }
+                cache_get(&ipm->h);
+        }
+        return ipm;
+}
+
+static inline void
+ip_map_cached_put(struct svc_rqst *rqstp, struct ip_map *ipm)
+{
+        struct svc_sock *svsk = rqstp->rq_sock;
+
+        if (svsk->sk_sock->type == SOCK_STREAM && svsk->sk_info_authunix == NULL)
+                svsk->sk_info_authunix = ipm;   /* newly cached, keep the reference */
+        else
+                cache_put(&ipm->h, &ip_map_cache);
+}
+
+void
+svcauth_unix_info_release(void *info)
+{
+        struct ip_map *ipm = info;
+        cache_put(&ipm->h, &ip_map_cache);
+}
+
 static int
 svcauth_unix_set_client(struct svc_rqst *rqstp)
 {
@@ -384,8 +423,10 @@ svcauth_unix_set_client(struct svc_rqst *rqstp)
         if (rqstp->rq_proc == 0)
                 return SVC_OK;
 
-        ipm = ip_map_lookup(rqstp->rq_server->sv_program->pg_class,
-                            rqstp->rq_addr.sin_addr);
+        ipm = ip_map_cached_get(rqstp);
+        if (ipm == NULL)
+                ipm = ip_map_lookup(rqstp->rq_server->sv_program->pg_class,
+                                    rqstp->rq_addr.sin_addr);
 
         if (ipm == NULL)
                 return SVC_DENIED;
@@ -400,7 +441,7 @@ svcauth_unix_set_client(struct svc_rqst *rqstp)
                 case 0:
                         rqstp->rq_client = &ipm->m_client->h;
                         kref_get(&rqstp->rq_client->ref);
-                        cache_put(&ipm->h, &ip_map_cache);
+                        ip_map_cached_put(rqstp, ipm);
                         break;
         }
         return SVC_OK;
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index cba85d195222..b39e7e2b648f 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -313,7 +313,7 @@ svc_sock_release(struct svc_rqst *rqstp)
 
         svc_release_skb(rqstp);
 
-        svc_free_allpages(rqstp);
+        svc_free_res_pages(rqstp);
         rqstp->rq_res.page_len = 0;
         rqstp->rq_res.page_base = 0;
 
@@ -412,7 +412,8 @@ svc_sendto(struct svc_rqst *rqstp, struct xdr_buf *xdr)
         /* send head */
         if (slen == xdr->head[0].iov_len)
                 flags = 0;
-        len = kernel_sendpage(sock, rqstp->rq_respages[0], 0, xdr->head[0].iov_len, flags);
+        len = kernel_sendpage(sock, rqstp->rq_respages[0], 0,
+                                  xdr->head[0].iov_len, flags);
         if (len != xdr->head[0].iov_len)
                 goto out;
         slen -= xdr->head[0].iov_len;
@@ -437,8 +438,9 @@ svc_sendto(struct svc_rqst *rqstp, struct xdr_buf *xdr)
         }
         /* send tail */
         if (xdr->tail[0].iov_len) {
-                result = kernel_sendpage(sock, rqstp->rq_respages[rqstp->rq_restailpage],
-                                             ((unsigned long)xdr->tail[0].iov_base)& (PAGE_SIZE-1),
+                result = kernel_sendpage(sock, rqstp->rq_respages[0],
+                                             ((unsigned long)xdr->tail[0].iov_base)
+                                                & (PAGE_SIZE-1),
                                              xdr->tail[0].iov_len, 0);
 
                 if (result > 0)
@@ -492,7 +494,12 @@ svc_sock_names(char *buf, struct svc_serv *serv, char *toclose)
         }
         spin_unlock(&serv->sv_lock);
         if (closesk)
+                /* Should unregister with portmap, but you cannot
+                 * unregister just one protocol...
+                 */
                 svc_delete_socket(closesk);
+        else if (toclose)
+                return -ENOENT;
         return len;
 }
 EXPORT_SYMBOL(svc_sock_names);
@@ -703,9 +710,11 @@ svc_udp_recvfrom(struct svc_rqst *rqstp)
         if (len <= rqstp->rq_arg.head[0].iov_len) {
                 rqstp->rq_arg.head[0].iov_len = len;
                 rqstp->rq_arg.page_len = 0;
+                rqstp->rq_respages = rqstp->rq_pages+1;
         } else {
                 rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len;
-                rqstp->rq_argused += (rqstp->rq_arg.page_len + PAGE_SIZE - 1)/ PAGE_SIZE;
+                rqstp->rq_respages = rqstp->rq_pages + 1 +
+                        (rqstp->rq_arg.page_len + PAGE_SIZE - 1)/ PAGE_SIZE;
         }
 
         if (serv->sv_stats)
@@ -946,7 +955,7 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp)
         struct svc_sock *svsk = rqstp->rq_sock;
         struct svc_serv *serv = svsk->sk_server;
         int             len;
-        struct kvec vec[RPCSVC_MAXPAGES];
+        struct kvec *vec;
         int pnum, vlen;
 
         dprintk("svc: tcp_recv %p data %d conn %d close %d\n",
@@ -1044,15 +1053,17 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp)
         len = svsk->sk_reclen;
         set_bit(SK_DATA, &svsk->sk_flags);
 
+        vec = rqstp->rq_vec;
         vec[0] = rqstp->rq_arg.head[0];
         vlen = PAGE_SIZE;
         pnum = 1;
         while (vlen < len) {
-                vec[pnum].iov_base = page_address(rqstp->rq_argpages[rqstp->rq_argused++]);
+                vec[pnum].iov_base = page_address(rqstp->rq_pages[pnum]);
                 vec[pnum].iov_len = PAGE_SIZE;
                 pnum++;
                 vlen += PAGE_SIZE;
         }
+        rqstp->rq_respages = &rqstp->rq_pages[pnum];
 
         /* Now receive data */
         len = svc_recvfrom(rqstp, vec, pnum, len);
@@ -1204,7 +1215,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout)
         struct svc_sock         *svsk =NULL;
         struct svc_serv         *serv = rqstp->rq_server;
         struct svc_pool         *pool = rqstp->rq_pool;
-        int                     len;
+        int                     len, i;
         int                     pages;
         struct xdr_buf          *arg;
         DECLARE_WAITQUEUE(wait, current);
@@ -1221,27 +1232,22 @@ svc_recv(struct svc_rqst *rqstp, long timeout)
                         "svc_recv: service %p, wait queue active!\n",
                          rqstp);
 
-        /* Initialize the buffers */
-        /* first reclaim pages that were moved to response list */
-        svc_pushback_allpages(rqstp);
 
         /* now allocate needed pages.  If we get a failure, sleep briefly */
         pages = 2 + (serv->sv_bufsz + PAGE_SIZE -1) / PAGE_SIZE;
-        while (rqstp->rq_arghi < pages) {
-                struct page *p = alloc_page(GFP_KERNEL);
-                if (!p) {
-                        schedule_timeout_uninterruptible(msecs_to_jiffies(500));
-                        continue;
+        for (i=0; i < pages ; i++)
+                while (rqstp->rq_pages[i] == NULL) {
+                        struct page *p = alloc_page(GFP_KERNEL);
+                        if (!p)
+                                schedule_timeout_uninterruptible(msecs_to_jiffies(500));
+                        rqstp->rq_pages[i] = p;
                 }
-                rqstp->rq_argpages[rqstp->rq_arghi++] = p;
-        }
 
         /* Make arg->head point to first page and arg->pages point to rest */
         arg = &rqstp->rq_arg;
-        arg->head[0].iov_base = page_address(rqstp->rq_argpages[0]);
+        arg->head[0].iov_base = page_address(rqstp->rq_pages[0]);
         arg->head[0].iov_len = PAGE_SIZE;
-        rqstp->rq_argused = 1;
-        arg->pages = rqstp->rq_argpages + 1;
+        arg->pages = rqstp->rq_pages + 1;
         arg->page_base = 0;
         /* save at least one page for response */
         arg->page_len = (pages-2)*PAGE_SIZE;
@@ -1604,6 +1610,8 @@ svc_delete_socket(struct svc_sock *svsk)
                         sockfd_put(svsk->sk_sock);
                 else
                         sock_release(svsk->sk_sock);
+                if (svsk->sk_info_authunix != NULL)
+                        svcauth_unix_info_release(svsk->sk_info_authunix);
                 kfree(svsk);
         } else {
                 spin_unlock_bh(&serv->sv_lock);
@@ -1699,6 +1707,7 @@ static int svc_deferred_recv(struct svc_rqst *rqstp)
         rqstp->rq_prot        = dr->prot;
         rqstp->rq_addr        = dr->addr;
         rqstp->rq_daddr       = dr->daddr;
+        rqstp->rq_respages    = rqstp->rq_pages;
         return dr->argslen<<2;
 }