1 files changed, 93 insertions, 102 deletions

diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 4d012920373..ce136323da8 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -14,7 +14,6 @@
 #include <net/sock.h>
 #include <net/ipv6.h>
 #include <linux/kernel.h>
-#include <linux/user_namespace.h>
 #define RPCDBG_FACILITY RPCDBG_AUTH
 
 #include <linux/sunrpc/clnt.h>
@@ -104,9 +103,23 @@ static void ip_map_put(struct kref *kref)
         kfree(im);
 }
 
-static inline int hash_ip6(const struct in6_addr *ip)
+#if IP_HASHBITS == 8
+/* hash_long on a 64 bit machine is currently REALLY BAD for
+ * IP addresses in reverse-endian (i.e. on a little-endian machine).
+ * So use a trivial but reliable hash instead
+ */
+static inline int hash_ip(__be32 ip)
+{
+        int hash = (__force u32)ip ^ ((__force u32)ip>>16);
+        return (hash ^ (hash>>8)) & 0xff;
+}
+#endif
+static inline int hash_ip6(struct in6_addr ip)
 {
-        return hash_32(ipv6_addr_hash(ip), IP_HASHBITS);
+        return (hash_ip(ip.s6_addr32[0]) ^
+                hash_ip(ip.s6_addr32[1]) ^
+                hash_ip(ip.s6_addr32[2]) ^
+                hash_ip(ip.s6_addr32[3]));
 }
 static int ip_map_match(struct cache_head *corig, struct cache_head *cnew)
 {
@@ -121,7 +134,7 @@ static void ip_map_init(struct cache_head *cnew, struct cache_head *citem)
         struct ip_map *item = container_of(citem, struct ip_map, h);
 
         strcpy(new->m_class, item->m_class);
-        new->m_addr = item->m_addr;
+        ipv6_addr_copy(&new->m_addr, &item->m_addr);
 }
 static void update(struct cache_head *cnew, struct cache_head *citem)
 {
@@ -198,7 +211,7 @@ static int ip_map_parse(struct cache_detail *cd,
         len = qword_get(&mesg, buf, mlen);
         if (len <= 0) return -EINVAL;
 
-        if (rpc_pton(cd->net, buf, len, &address.sa, sizeof(address)) == 0)
+        if (rpc_pton(buf, len, &address.sa, sizeof(address)) == 0)
                 return -EINVAL;
         switch (address.sa.sa_family) {
         case AF_INET:
@@ -207,7 +220,7 @@ static int ip_map_parse(struct cache_detail *cd,
                 ipv6_addr_set_v4mapped(address.s4.sin_addr.s_addr,
                                 &sin6.sin6_addr);
                 break;
-#if IS_ENABLED(CONFIG_IPV6)
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
         case AF_INET6:
                 memcpy(&sin6, &address.s6, sizeof(sin6));
                 break;
@@ -261,7 +274,7 @@ static int ip_map_show(struct seq_file *m,
         }
         im = container_of(h, struct ip_map, h);
         /* class addr domain */
-        addr = im->m_addr;
+        ipv6_addr_copy(&addr, &im->m_addr);
 
         if (test_bit(CACHE_VALID, &h->flags) &&
             !test_bit(CACHE_NEGATIVE, &h->flags))
@@ -284,10 +297,10 @@ static struct ip_map *__ip_map_lookup(struct cache_detail *cd, char *class,
         struct cache_head *ch;
 
         strcpy(ip.m_class, class);
-        ip.m_addr = *addr;
+        ipv6_addr_copy(&ip.m_addr, addr);
         ch = sunrpc_cache_lookup(cd, &ip.h,
                                  hash_str(class, IP_HASHBITS) ^
-                                 hash_ip6(addr));
+                                 hash_ip6(*addr));
 
         if (ch)
                 return container_of(ch, struct ip_map, h);
@@ -317,7 +330,7 @@ static int __ip_map_update(struct cache_detail *cd, struct ip_map *ipm,
         ip.h.expiry_time = expiry;
         ch = sunrpc_cache_update(cd, &ip.h, &ipm->h,
                                  hash_str(ipm->m_class, IP_HASHBITS) ^
-                                 hash_ip6(&ipm->m_addr));
+                                 hash_ip6(ipm->m_addr));
         if (!ch)
                 return -ENOMEM;
         cache_put(ch, cd);
@@ -333,12 +346,17 @@ static inline int ip_map_update(struct net *net, struct ip_map *ipm,
         return __ip_map_update(sn->ip_map_cache, ipm, udom, expiry);
 }
 
-void svcauth_unix_purge(struct net *net)
+
+void svcauth_unix_purge(void)
 {
-        struct sunrpc_net *sn;
+        struct net *net;
 
-        sn = net_generic(net, sunrpc_net_id);
-        cache_purge(sn->ip_map_cache);
+        for_each_net(net) {
+                struct sunrpc_net *sn;
+
+                sn = net_generic(net, sunrpc_net_id);
+                cache_purge(sn->ip_map_cache);
+        }
 }
 EXPORT_SYMBOL_GPL(svcauth_unix_purge);
 
@@ -418,6 +436,7 @@ struct unix_gid {
         uid_t                   uid;
         struct group_info       *gi;
 };
+static struct cache_head        *gid_table[GID_HASHMAX];
 
 static void unix_gid_put(struct kref *kref)
 {
@@ -475,7 +494,8 @@ static int unix_gid_upcall(struct cache_detail *cd, struct cache_head *h)
         return sunrpc_cache_pipe_upcall(cd, h, unix_gid_request);
 }
 
-static struct unix_gid *unix_gid_lookup(struct cache_detail *cd, uid_t uid);
+static struct unix_gid *unix_gid_lookup(uid_t uid);
+extern struct cache_detail unix_gid_cache;
 
 static int unix_gid_parse(struct cache_detail *cd,
                         char *mesg, int mlen)
@@ -489,7 +509,7 @@ static int unix_gid_parse(struct cache_detail *cd,
         time_t expiry;
         struct unix_gid ug, *ugp;
 
-        if (mesg[mlen - 1] != '\n')
+        if (mlen <= 0 || mesg[mlen-1] != '\n')
                 return -EINVAL;
         mesg[mlen-1] = 0;
 
@@ -512,30 +532,26 @@ static int unix_gid_parse(struct cache_detail *cd,
 
         for (i = 0 ; i < gids ; i++) {
                 int gid;
-                kgid_t kgid;
                 rv = get_int(&mesg, &gid);
                 err = -EINVAL;
                 if (rv)
                         goto out;
-                kgid = make_kgid(&init_user_ns, gid);
-                if (!gid_valid(kgid))
-                        goto out;
-                GROUP_AT(ug.gi, i) = kgid;
+                GROUP_AT(ug.gi, i) = gid;
         }
 
-        ugp = unix_gid_lookup(cd, uid);
+        ugp = unix_gid_lookup(uid);
         if (ugp) {
                 struct cache_head *ch;
                 ug.h.flags = 0;
                 ug.h.expiry_time = expiry;
-                ch = sunrpc_cache_update(cd,
+                ch = sunrpc_cache_update(&unix_gid_cache,
                                          &ug.h, &ugp->h,
                                          hash_long(uid, GID_HASHBITS));
                 if (!ch)
                         err = -ENOMEM;
                 else {
                         err = 0;
-                        cache_put(ch, cd);
+                        cache_put(ch, &unix_gid_cache);
                 }
         } else
                 err = -ENOMEM;
@@ -549,7 +565,6 @@ static int unix_gid_show(struct seq_file *m,
                          struct cache_detail *cd,
                          struct cache_head *h)
 {
-        struct user_namespace *user_ns = current_user_ns();
         struct unix_gid *ug;
         int i;
         int glen;
@@ -567,14 +582,15 @@ static int unix_gid_show(struct seq_file *m,
 
         seq_printf(m, "%u %d:", ug->uid, glen);
         for (i = 0; i < glen; i++)
-                seq_printf(m, " %d", from_kgid_munged(user_ns, GROUP_AT(ug->gi, i)));
+                seq_printf(m, " %d", GROUP_AT(ug->gi, i));
         seq_printf(m, "\n");
         return 0;
 }
 
-static struct cache_detail unix_gid_cache_template = {
+struct cache_detail unix_gid_cache = {
         .owner          = THIS_MODULE,
         .hash_size      = GID_HASHMAX,
+        .hash_table     = gid_table,
         .name           = "auth.unix.gid",
         .cache_put      = unix_gid_put,
         .cache_upcall   = unix_gid_upcall,
@@ -586,42 +602,14 @@ static struct cache_detail unix_gid_cache_template = {
         .alloc          = unix_gid_alloc,
 };
 
-int unix_gid_cache_create(struct net *net)
-{
-        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
-        struct cache_detail *cd;
-        int err;
-
-        cd = cache_create_net(&unix_gid_cache_template, net);
-        if (IS_ERR(cd))
-                return PTR_ERR(cd);
-        err = cache_register_net(cd, net);
-        if (err) {
-                cache_destroy_net(cd, net);
-                return err;
-        }
-        sn->unix_gid_cache = cd;
-        return 0;
-}
-
-void unix_gid_cache_destroy(struct net *net)
-{
-        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
-        struct cache_detail *cd = sn->unix_gid_cache;
-
-        sn->unix_gid_cache = NULL;
-        cache_purge(cd);
-        cache_unregister_net(cd, net);
-        cache_destroy_net(cd, net);
-}
-
-static struct unix_gid *unix_gid_lookup(struct cache_detail *cd, uid_t uid)
+static struct unix_gid *unix_gid_lookup(uid_t uid)
 {
         struct unix_gid ug;
         struct cache_head *ch;
 
         ug.uid = uid;
-        ch = sunrpc_cache_lookup(cd, &ug.h, hash_long(uid, GID_HASHBITS));
+        ch = sunrpc_cache_lookup(&unix_gid_cache, &ug.h,
+                                 hash_long(uid, GID_HASHBITS));
         if (ch)
                 return container_of(ch, struct unix_gid, h);
         else
@@ -633,13 +621,11 @@ static struct group_info *unix_gid_find(uid_t uid, struct svc_rqst *rqstp)
         struct unix_gid *ug;
         struct group_info *gi;
         int ret;
-        struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net,
-                                            sunrpc_net_id);
 
-        ug = unix_gid_lookup(sn->unix_gid_cache, uid);
+        ug = unix_gid_lookup(uid);
         if (!ug)
                 return ERR_PTR(-EAGAIN);
-        ret = cache_check(sn->unix_gid_cache, &ug->h, &rqstp->rq_chandle);
+        ret = cache_check(&unix_gid_cache, &ug->h, &rqstp->rq_chandle);
         switch (ret) {
         case -ENOENT:
                 return ERR_PTR(-ENOENT);
@@ -647,7 +633,7 @@ static struct group_info *unix_gid_find(uid_t uid, struct svc_rqst *rqstp)
                 return ERR_PTR(-ESHUTDOWN);
         case 0:
                 gi = get_group_info(ug->gi);
-                cache_put(&ug->h, sn->unix_gid_cache);
+                cache_put(&ug->h, &unix_gid_cache);
                 return gi;
         default:
                 return ERR_PTR(-EAGAIN);
@@ -732,7 +718,6 @@ svcauth_null_accept(struct svc_rqst *rqstp, __be32 *authp)
         struct svc_cred *cred = &rqstp->rq_cred;
 
         cred->cr_group_info = NULL;
-        cred->cr_principal = NULL;
         rqstp->rq_client = NULL;
 
         if (argv->iov_len < 3*4)
@@ -760,7 +745,7 @@ svcauth_null_accept(struct svc_rqst *rqstp, __be32 *authp)
         svc_putnl(resv, RPC_AUTH_NULL);
         svc_putnl(resv, 0);
 
-        rqstp->rq_cred.cr_flavor = RPC_AUTH_NULL;
+        rqstp->rq_flavor = RPC_AUTH_NULL;
         return SVC_OK;
 }
 
@@ -798,7 +783,6 @@ svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
         int             len   = argv->iov_len;
 
         cred->cr_group_info = NULL;
-        cred->cr_principal = NULL;
         rqstp->rq_client = NULL;
 
         if ((len -= 3*4) < 0)
@@ -820,12 +804,8 @@ svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
         cred->cr_group_info = groups_alloc(slen);
         if (cred->cr_group_info == NULL)
                 return SVC_CLOSE;
-        for (i = 0; i < slen; i++) {
-                kgid_t kgid = make_kgid(&init_user_ns, svc_getnl(argv));
-                if (!gid_valid(kgid))
-                        goto badcred;
-                GROUP_AT(cred->cr_group_info, i) = kgid;
-        }
+        for (i = 0; i < slen; i++)
+                GROUP_AT(cred->cr_group_info, i) = svc_getnl(argv);
         if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
                 *authp = rpc_autherr_badverf;
                 return SVC_DENIED;
@@ -835,7 +815,7 @@ svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
         svc_putnl(resv, RPC_AUTH_NULL);
         svc_putnl(resv, 0);
 
-        rqstp->rq_cred.cr_flavor = RPC_AUTH_UNIX;
+        rqstp->rq_flavor = RPC_AUTH_UNIX;
         return SVC_OK;
 
 badcred:
@@ -869,45 +849,56 @@ struct auth_ops svcauth_unix = {
         .set_client     = svcauth_unix_set_client,
 };
 
-static struct cache_detail ip_map_cache_template = {
-        .owner          = THIS_MODULE,
-        .hash_size      = IP_HASHMAX,
-        .name           = "auth.unix.ip",
-        .cache_put      = ip_map_put,
-        .cache_upcall   = ip_map_upcall,
-        .cache_parse    = ip_map_parse,
-        .cache_show     = ip_map_show,
-        .match          = ip_map_match,
-        .init           = ip_map_init,
-        .update         = update,
-        .alloc          = ip_map_alloc,
-};
-
 int ip_map_cache_create(struct net *net)
 {
-        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+        int err = -ENOMEM;
         struct cache_detail *cd;
-        int err;
+        struct cache_head **tbl;
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+
+        cd = kzalloc(sizeof(struct cache_detail), GFP_KERNEL);
+        if (cd == NULL)
+                goto err_cd;
+
+        tbl = kzalloc(IP_HASHMAX * sizeof(struct cache_head *), GFP_KERNEL);
+        if (tbl == NULL)
+                goto err_tbl;
+
+        cd->owner = THIS_MODULE,
+        cd->hash_size = IP_HASHMAX,
+        cd->hash_table = tbl,
+        cd->name = "auth.unix.ip",
+        cd->cache_put = ip_map_put,
+        cd->cache_upcall = ip_map_upcall,
+        cd->cache_parse = ip_map_parse,
+        cd->cache_show = ip_map_show,
+        cd->match = ip_map_match,
+        cd->init = ip_map_init,
+        cd->update = update,
+        cd->alloc = ip_map_alloc,
 
-        cd = cache_create_net(&ip_map_cache_template, net);
-        if (IS_ERR(cd))
-                return PTR_ERR(cd);
         err = cache_register_net(cd, net);
-        if (err) {
-                cache_destroy_net(cd, net);
-                return err;
-        }
+        if (err)
+                goto err_reg;
+
         sn->ip_map_cache = cd;
         return 0;
+
+err_reg:
+        kfree(tbl);
+err_tbl:
+        kfree(cd);
+err_cd:
+        return err;
 }
 
 void ip_map_cache_destroy(struct net *net)
 {
-        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
-        struct cache_detail *cd = sn->ip_map_cache;
+        struct sunrpc_net *sn;
 
-        sn->ip_map_cache = NULL;
-        cache_purge(cd);
-        cache_unregister_net(cd, net);
-        cache_destroy_net(cd, net);
+        sn = net_generic(net, sunrpc_net_id);
+        cache_purge(sn->ip_map_cache);
+        cache_unregister_net(sn->ip_map_cache, net);
+        kfree(sn->ip_map_cache->hash_table);
+        kfree(sn->ip_map_cache);
 }