net/rds: Implement ARP flushing correctly

If a remote peer has moved its IP address from one port to the other,
the local node may have an incorrect ARP entry in its cache. During
connection management, we will then get back a route-error-event from
the CM.

Current code attempts to flush the ARP entry from the cache. However,
1) it does not check for return values, 2) it does not supply the
device name, 3) it does not iterate over all possible device names,
and 4) its doesn't supply the correct flags.

Due to 2-4 above, the flushing doesn't work.

This commit fixes this.

On a system with a single CX-3 and 16 VFs, fail-over just after a
fail-back is reduced from ~60 seconds down to ~10 seconds with the fix
(1156 RDS connections).

The fix for UEK5 is slightly more complicated compared to the UEK4
variants, because rdmaip has moved stuff out of the rds_rdma module
and due to RoCE. Hence, this commit detects possible IB link-layers
and flushes the ARP cache for the possible devices accordingly.

This is a temporary fix and should be moved out of the rds_rdma module
and into the rdmaip module, as tracked by ER 28341928 - Move ARP
flushing logic from rds_rdma to rdmaip.

V1 -> V2:
   * Added correct use of netmask for the ATF_PUBL flag (Ka-Cheong)
   * Moved the link-layer detected flags into the rds_ib_transport
     struct (Ka-Cheong)

V2 -> V3:
   * Added to commit message that this is a temporary fix (Santosh)
   * Added Santosh' r-b

Orabug: 28219823

Signed-off-by: Håkon Bugge <[email protected]>
Reviewed-by: [email protected]

Author: Hakon-Bugge

net/rds/ib.c

@@ -30,7 +30,10 @@
  * SOFTWARE.
  *
  */
+#include <linux/if_arp.h>
+#include <linux/sockios.h>
 #include <net/addrconf.h>
+#include <net/inet_common.h>
 
 #include "ib.h"
 #include "rds_single_path.h"
@@ -463,6 +466,34 @@ static int rds_ib_laddr_check(struct net *net, const struct in6_addr *addr,
 	return ret;
 }
 
+/* Detect possible link-layers in order to flush ARP correctly */
+static void detect_link_layers(struct ib_device *ibdev)
+{
+	if (ibdev->get_link_layer) {
+		u8 port;
+
+		for (port = 1; port <= ibdev->phys_port_cnt; ++port) {
+			switch (ibdev->get_link_layer(ibdev, port)) {
+			case IB_LINK_LAYER_UNSPECIFIED:
+				rds_ib_transport.t_ll_ib_detected = true;
+				rds_ib_transport.t_ll_eth_detected = true;
+				break;
+
+			case IB_LINK_LAYER_INFINIBAND:
+				rds_ib_transport.t_ll_ib_detected = true;
+				break;
+
+			case IB_LINK_LAYER_ETHERNET:
+				rds_ib_transport.t_ll_eth_detected = true;
+				break;
+			}
+		}
+	} else {
+		rds_ib_transport.t_ll_ib_detected = true;
+		rds_ib_transport.t_ll_eth_detected = true;
+	}
+}
+
 void rds_ib_add_one(struct ib_device *device)
 {
 	struct rds_ib_device *rds_ibdev;
@@ -477,6 +508,8 @@ void rds_ib_add_one(struct ib_device *device)
 	if (device->node_type != RDMA_NODE_IB_CA)
 		return;
 
+	detect_link_layers(device);
+
 	dev_attr = kmalloc(sizeof(*dev_attr), GFP_KERNEL);
 	if (!dev_attr)
 		return;
@@ -772,5 +805,97 @@ int rds_ib_inc_to_skb(struct rds_incoming *inc, struct sk_buff *skb)
 	return ret;
 }
 
-MODULE_LICENSE("GPL");
+static void __flush_arp_entry(struct arpreq *r, char name[IFNAMSIZ])
+{
+	int ret;
 
+	r->arp_flags = ATF_PERM;
+	((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr = htonl(0);
+	strcpy(r->arp_dev, name);
+	ret = inet_ioctl(rds_ib_inet_socket, SIOCDARP, (unsigned long)r);
+	if ((ret == -ENOENT) || (ret == -ENXIO)) {
+		r->arp_flags |= ATF_PUBL;
+		((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr = htonl(0xFFFFFFFF);
+		ret = inet_ioctl(rds_ib_inet_socket, SIOCDARP, (unsigned long)r);
+	}
+
+	if (ret && (ret != -ENOENT) && (ret != -ENXIO))
+		pr_err("SIOCDARP failed, err %d, addr %pI4, flags 0x%x, device %s\n",
+		       ret, &((struct sockaddr_in *)r)->sin_addr.s_addr,
+		       r->arp_flags, r->arp_dev);
+}
+
+static void __flush_eth_arp_entry(struct arpreq *r)
+{
+	struct rds_ib_device *rds_ibdev;
+
+	down_read(&rds_ib_devices_lock);
+	list_for_each_entry(rds_ibdev, &rds_ib_devices, list) {
+		struct ib_device *ibdev = rds_ibdev->dev;
+		u8 port;
+
+		if (!ibdev->get_netdev)
+			continue;
+
+		for (port = 1; port <= ibdev->phys_port_cnt; ++port) {
+			struct net_device *ndev = ibdev->get_netdev(ibdev, port);
+
+			if (ndev)
+				__flush_arp_entry(r, ndev->name);
+		}
+	}
+	up_read(&rds_ib_devices_lock);
+}
+
+static void __flush_ib_arp_entry(struct arpreq *r)
+{
+	struct net_device *ndev;
+
+	read_lock(&dev_base_lock);
+	for_each_netdev(&init_net, ndev)
+		if (ndev->type == ARPHRD_INFINIBAND)
+			__flush_arp_entry(r, ndev->name);
+	read_unlock(&dev_base_lock);
+}
+
+void rds_ib_flush_arp_entry(struct in6_addr *prot_addr)
+{
+	struct sockaddr_in *sin;
+	struct page *page;
+	struct arpreq *r;
+
+	if (!ipv6_addr_v4mapped(prot_addr)) {
+		/* Addressed by bug 28220027 */
+		pr_err("IPv6 addresses are not flushed from ARP cache");
+		return;
+	}
+
+	page = alloc_page(GFP_HIGHUSER);
+	if (!page) {
+		pr_err("alloc_page failed");
+		return;
+	}
+
+	r = (struct arpreq *)kmap(page);
+	if (!r) {
+		pr_err("kmap failed");
+		goto out_free;
+	}
+
+	memset(r, 0, sizeof(struct arpreq));
+	sin = (struct sockaddr_in *)&r->arp_pa;
+	sin->sin_family = AF_INET;
+	sin->sin_addr.s_addr = prot_addr->s6_addr32[3];
+
+	if (rds_ib_transport.t_ll_eth_detected)
+		__flush_eth_arp_entry(r);
+	if (rds_ib_transport.t_ll_ib_detected)
+		__flush_ib_arp_entry(r);
+
+	kunmap(page);
+
+out_free:
+	__free_page(page);
+}
+
+MODULE_LICENSE("GPL");

net/rds/ib.h

@@ -467,6 +467,7 @@ extern struct workqueue_struct *rds_aux_wq;
 extern struct rds_transport rds_ib_transport;
 extern void rds_ib_add_one(struct ib_device *device);
 extern void rds_ib_remove_one(struct ib_device *device, void *client_data);
+extern void rds_ib_flush_arp_entry(struct in6_addr *prot_addr);
 void rds_ib_srq_exit(struct rds_ib_device *rds_ibdev);
 int rds_ib_srq_init(struct rds_ib_device *rds_ibdev);
 

net/rds/rdma_transport.c

@@ -90,9 +90,6 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id,
 	/* this can be null in the listening path */
 	struct rds_connection *conn = cm_id->context;
 	struct rds_transport *trans = &rds_ib_transport;
-	struct page *page;
-	struct arpreq *r;
-	struct sockaddr_in *sin;
 	int ret = 0;
 	int *err;
 
@@ -178,24 +175,7 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id,
 
 	case RDMA_CM_EVENT_ROUTE_ERROR:
 		/* IP might have been moved so flush the ARP entry and retry */
-		page = alloc_page(GFP_HIGHUSER);
-		if (!page) {
-			printk(KERN_ERR "alloc_page failed .. NO MEM\n");
-			ret = -ENOMEM;
-		} else {
-			if (ipv6_addr_v4mapped(&conn->c_faddr)) {
-				r = (struct arpreq *)kmap(page);
-				memset(r, 0, sizeof(struct arpreq));
-				sin = (struct sockaddr_in *)&r->arp_pa;
-				sin->sin_family = AF_INET;
-				sin->sin_addr.s_addr =
-				    conn->c_faddr.s6_addr32[3];
-				inet_ioctl(rds_ib_inet_socket, SIOCDARP,
-					   (unsigned long)r);
-				kunmap(page);
-				__free_page(page);
-			}
-		}
+		rds_ib_flush_arp_entry(&conn->c_faddr);
 
 		if (conn) {
 			rds_rtd_ptr(RDS_RTD_ERR,

net/rds/rds.h

@@ -663,7 +663,9 @@ struct rds_transport {
 	struct list_head	t_item;
 	struct module		*t_owner;
 	unsigned int		t_prefer_loopback:1,
-				t_mp_capable:1;
+				t_mp_capable:1,
+				t_ll_ib_detected:1,
+				t_ll_eth_detected:1;
 	unsigned int		t_type;
 
 	int (*laddr_check)(struct net *net, const struct in6_addr *addr,