Merge tag 'mlx5-fixes-2019-09-24' of git://git.kernel.org/pub/scm/linux/kernel/git...

[linux.git] / net / rds / af_rds.c

diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index 2b969f99ef1311f845baea874a985714cb051c7c..1a5bf3fa4578b85dc6a5ed4f3cdb1a0ca95a5447 100644 (file)
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2019 Oracle and/or its affiliates. All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
@@ -559,7 +559,7 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr,
                        ret = -EDESTADDRREQ;
                        break;
                }
-               if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) ||
+               if (ipv4_is_multicast(sin->sin_addr.s_addr) ||
                    sin->sin_addr.s_addr == htonl(INADDR_BROADCAST)) {
                        ret = -EINVAL;
                        break;
@@ -593,7 +593,7 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr,
                        addr4 = sin6->sin6_addr.s6_addr32[3];
                        if (addr4 == htonl(INADDR_ANY) ||
                            addr4 == htonl(INADDR_BROADCAST) ||
-                           IN_MULTICAST(ntohl(addr4))) {
+                           ipv4_is_multicast(addr4)) {
                                ret = -EPROTOTYPE;
                                break;
                        }
@@ -705,7 +705,7 @@ static int rds_create(struct net *net, struct socket *sock, int protocol,
        if (sock->type != SOCK_SEQPACKET || protocol)
                return -ESOCKTNOSUPPORT;
 
-       sk = sk_alloc(net, AF_RDS, GFP_ATOMIC, &rds_proto, kern);
+       sk = sk_alloc(net, AF_RDS, GFP_KERNEL, &rds_proto, kern);
        if (!sk)
                return -ENOMEM;
 
@@ -741,6 +741,10 @@ static void rds_sock_inc_info(struct socket *sock, unsigned int len,
        spin_lock_bh(&rds_sock_lock);
 
        list_for_each_entry(rs, &rds_sock_list, rs_item) {
+               /* This option only supports IPv4 sockets. */
+               if (!ipv6_addr_v4mapped(&rs->rs_bound_addr))
+                       continue;
+
                read_lock(&rs->rs_recv_lock);
 
                /* XXX too lazy to maintain counts.. */
@@ -762,21 +766,60 @@ static void rds_sock_inc_info(struct socket *sock, unsigned int len,
        lens->each = sizeof(struct rds_info_message);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
+static void rds6_sock_inc_info(struct socket *sock, unsigned int len,
+                              struct rds_info_iterator *iter,
+                              struct rds_info_lengths *lens)
+{
+       struct rds_incoming *inc;
+       unsigned int total = 0;
+       struct rds_sock *rs;
+
+       len /= sizeof(struct rds6_info_message);
+
+       spin_lock_bh(&rds_sock_lock);
+
+       list_for_each_entry(rs, &rds_sock_list, rs_item) {
+               read_lock(&rs->rs_recv_lock);
+
+               list_for_each_entry(inc, &rs->rs_recv_queue, i_item) {
+                       total++;
+                       if (total <= len)
+                               rds6_inc_info_copy(inc, iter, &inc->i_saddr,
+                                                  &rs->rs_bound_addr, 1);
+               }
+
+               read_unlock(&rs->rs_recv_lock);
+       }
+
+       spin_unlock_bh(&rds_sock_lock);
+
+       lens->nr = total;
+       lens->each = sizeof(struct rds6_info_message);
+}
+#endif
+
 static void rds_sock_info(struct socket *sock, unsigned int len,
                          struct rds_info_iterator *iter,
                          struct rds_info_lengths *lens)
 {
        struct rds_info_socket sinfo;
+       unsigned int cnt = 0;
        struct rds_sock *rs;
 
        len /= sizeof(struct rds_info_socket);
 
        spin_lock_bh(&rds_sock_lock);
 
-       if (len < rds_sock_count)
+       if (len < rds_sock_count) {
+               cnt = rds_sock_count;
                goto out;
+       }
 
        list_for_each_entry(rs, &rds_sock_list, rs_item) {
+               /* This option only supports IPv4 sockets. */
+               if (!ipv6_addr_v4mapped(&rs->rs_bound_addr))
+                       continue;
                sinfo.sndbuf = rds_sk_sndbuf(rs);
                sinfo.rcvbuf = rds_sk_rcvbuf(rs);
                sinfo.bound_addr = rs->rs_bound_addr_v4;
@@ -786,15 +829,51 @@ static void rds_sock_info(struct socket *sock, unsigned int len,
                sinfo.inum = sock_i_ino(rds_rs_to_sk(rs));
 
                rds_info_copy(iter, &sinfo, sizeof(sinfo));
+               cnt++;
        }
 
 out:
-       lens->nr = rds_sock_count;
+       lens->nr = cnt;
        lens->each = sizeof(struct rds_info_socket);
 
        spin_unlock_bh(&rds_sock_lock);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
+static void rds6_sock_info(struct socket *sock, unsigned int len,
+                          struct rds_info_iterator *iter,
+                          struct rds_info_lengths *lens)
+{
+       struct rds6_info_socket sinfo6;
+       struct rds_sock *rs;
+
+       len /= sizeof(struct rds6_info_socket);
+
+       spin_lock_bh(&rds_sock_lock);
+
+       if (len < rds_sock_count)
+               goto out;
+
+       list_for_each_entry(rs, &rds_sock_list, rs_item) {
+               sinfo6.sndbuf = rds_sk_sndbuf(rs);
+               sinfo6.rcvbuf = rds_sk_rcvbuf(rs);
+               sinfo6.bound_addr = rs->rs_bound_addr;
+               sinfo6.connected_addr = rs->rs_conn_addr;
+               sinfo6.bound_port = rs->rs_bound_port;
+               sinfo6.connected_port = rs->rs_conn_port;
+               sinfo6.inum = sock_i_ino(rds_rs_to_sk(rs));
+
+               rds_info_copy(iter, &sinfo6, sizeof(sinfo6));
+       }
+
+ out:
+       lens->nr = rds_sock_count;
+       lens->each = sizeof(struct rds6_info_socket);
+
+       spin_unlock_bh(&rds_sock_lock);
+}
+#endif
+
 static void rds_exit(void)
 {
        sock_unregister(rds_family_ops.family);
@@ -808,6 +887,10 @@ static void rds_exit(void)
        rds_bind_lock_destroy();
        rds_info_deregister_func(RDS_INFO_SOCKETS, rds_sock_info);
        rds_info_deregister_func(RDS_INFO_RECV_MESSAGES, rds_sock_inc_info);
+#if IS_ENABLED(CONFIG_IPV6)
+       rds_info_deregister_func(RDS6_INFO_SOCKETS, rds6_sock_info);
+       rds_info_deregister_func(RDS6_INFO_RECV_MESSAGES, rds6_sock_inc_info);
+#endif
 }
 module_exit(rds_exit);
 
@@ -845,6 +928,10 @@ static int rds_init(void)
 
        rds_info_register_func(RDS_INFO_SOCKETS, rds_sock_info);
        rds_info_register_func(RDS_INFO_RECV_MESSAGES, rds_sock_inc_info);
+#if IS_ENABLED(CONFIG_IPV6)
+       rds_info_register_func(RDS6_INFO_SOCKETS, rds6_sock_info);
+       rds_info_register_func(RDS6_INFO_RECV_MESSAGES, rds6_sock_inc_info);
+#endif
 
        goto out;