Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1d248b25 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (26 commits)
  IB/mlx4: Set ownership bit correctly when copying CQEs during CQ resize
  RDMA/nes: Remove tx_free_list
  RDMA/cma: Add IPv6 support
  RDMA/addr: Add support for translating IPv6 addresses
  mlx4_core: Delete incorrect comment
  mlx4_core: Add support for multiple completion event vectors
  IB/iser: Avoid recv buffer exhaustion caused by unexpected PDUs
  IB/ehca: Remove redundant test of vpage
  IB/ehca: Replace modulus operations in flush error completion path
  IB/ipath: Add locking for interrupt use of ipath_pd contexts vs free
  IB/ipath: Fix spi_pioindex value
  IB/ipath: Only do 1X workaround on rev1 chips
  IB/ipath: Don't count IB symbol and link errors unless link is UP
  IB/ipath: Check return value of dma_map_single()
  IB/ipath: Fix PSN of send WQEs after an RDMA read resend
  RDMA/nes: Cleanup warnings
  RDMA/nes: Add loopback check to make_cm_node()
  RDMA/nes: Check cqp_avail_reqs is empty after locking the list
  RDMA/nes: Fix TCP compliance test failures
  RDMA/nes: Forward packets for a new connection with stale APBVT entry
  ...
parents 1db2a5c1 2a0d8366

drivers/infiniband/core/addr.c

+151 −45
Original line number Diff line number Diff line
@@ -41,6 +41,8 @@ 
#include <net/neighbour.h>

#include <net/route.h>

#include <net/netevent.h>

#include <net/addrconf.h>

#include <net/ip6_route.h>

#include <rdma/ib_addr.h>



MODULE_AUTHOR("Sean Hefty");
@@ -49,8 +51,8 @@ MODULE_LICENSE("Dual BSD/GPL"); 


struct addr_req {

	struct list_head list;

	struct sockaddr src_addr;

	struct sockaddr dst_addr;

	struct sockaddr_storage src_addr;

	struct sockaddr_storage dst_addr;

	struct rdma_dev_addr *addr;

	struct rdma_addr_client *client;

	void *context;
@@ -113,15 +115,32 @@ EXPORT_SYMBOL(rdma_copy_addr); 
int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)

{

	struct net_device *dev;

	__be32 ip = ((struct sockaddr_in *) addr)->sin_addr.s_addr;

	int ret;

	int ret = -EADDRNOTAVAIL;



	switch (addr->sa_family) {

	case AF_INET:

		dev = ip_dev_find(&init_net,

			((struct sockaddr_in *) addr)->sin_addr.s_addr);



	dev = ip_dev_find(&init_net, ip);

		if (!dev)

		return -EADDRNOTAVAIL;

			return ret;



		ret = rdma_copy_addr(dev_addr, dev, NULL);

		dev_put(dev);

		break;

	case AF_INET6:

		for_each_netdev(&init_net, dev) {

			if (ipv6_chk_addr(&init_net,

					  &((struct sockaddr_in6 *) addr)->sin6_addr,

					  dev, 1)) {

				ret = rdma_copy_addr(dev_addr, dev, NULL);

				break;

			}

		}

		break;

	default:

		break;

	}

	return ret;

}

EXPORT_SYMBOL(rdma_translate_ip);
@@ -156,22 +175,37 @@ static void queue_req(struct addr_req *req) 
	mutex_unlock(&lock);

}



static void addr_send_arp(struct sockaddr_in *dst_in)

static void addr_send_arp(struct sockaddr *dst_in)

{

	struct rtable *rt;

	struct flowi fl;

	__be32 dst_ip = dst_in->sin_addr.s_addr;

	struct dst_entry *dst;



	memset(&fl, 0, sizeof fl);

	fl.nl_u.ip4_u.daddr = dst_ip;

	if (dst_in->sa_family == AF_INET)  {

		fl.nl_u.ip4_u.daddr =

			((struct sockaddr_in *) dst_in)->sin_addr.s_addr;



		if (ip_route_output_key(&init_net, &rt, &fl))

			return;



		neigh_event_send(rt->u.dst.neighbour, NULL);

		ip_rt_put(rt);



	} else {

		fl.nl_u.ip6_u.daddr =

			((struct sockaddr_in6 *) dst_in)->sin6_addr;



		dst = ip6_route_output(&init_net, NULL, &fl);

		if (!dst)

			return;



		neigh_event_send(dst->neighbour, NULL);

		dst_release(dst);

	}

}



static int addr_resolve_remote(struct sockaddr_in *src_in,

static int addr4_resolve_remote(struct sockaddr_in *src_in,

			       struct sockaddr_in *dst_in,

			       struct rdma_dev_addr *addr)

{
@@ -220,10 +254,51 @@ static int addr_resolve_remote(struct sockaddr_in *src_in, 
	return ret;

}



static int addr6_resolve_remote(struct sockaddr_in6 *src_in,

			       struct sockaddr_in6 *dst_in,

			       struct rdma_dev_addr *addr)

{

	struct flowi fl;

	struct neighbour *neigh;

	struct dst_entry *dst;

	int ret = -ENODATA;



	memset(&fl, 0, sizeof fl);

	fl.nl_u.ip6_u.daddr = dst_in->sin6_addr;

	fl.nl_u.ip6_u.saddr = src_in->sin6_addr;



	dst = ip6_route_output(&init_net, NULL, &fl);

	if (!dst)

		return ret;



	if (dst->dev->flags & IFF_NOARP) {

		ret = rdma_copy_addr(addr, dst->dev, NULL);

	} else {

		neigh = dst->neighbour;

		if (neigh && (neigh->nud_state & NUD_VALID))

			ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);

	}



	dst_release(dst);

	return ret;

}



static int addr_resolve_remote(struct sockaddr *src_in,

				struct sockaddr *dst_in,

				struct rdma_dev_addr *addr)

{

	if (src_in->sa_family == AF_INET) {

		return addr4_resolve_remote((struct sockaddr_in *) src_in,

			(struct sockaddr_in *) dst_in, addr);

	} else

		return addr6_resolve_remote((struct sockaddr_in6 *) src_in,

			(struct sockaddr_in6 *) dst_in, addr);

}



static void process_req(struct work_struct *work)

{

	struct addr_req *req, *temp_req;

	struct sockaddr_in *src_in, *dst_in;

	struct sockaddr *src_in, *dst_in;

	struct list_head done_list;



	INIT_LIST_HEAD(&done_list);
@@ -231,8 +306,8 @@ static void process_req(struct work_struct *work) 
	mutex_lock(&lock);

	list_for_each_entry_safe(req, temp_req, &req_list, list) {

		if (req->status == -ENODATA) {

			src_in = (struct sockaddr_in *) &req->src_addr;

			dst_in = (struct sockaddr_in *) &req->dst_addr;

			src_in = (struct sockaddr *) &req->src_addr;

			dst_in = (struct sockaddr *) &req->dst_addr;

			req->status = addr_resolve_remote(src_in, dst_in,

							  req->addr);

			if (req->status && time_after_eq(jiffies, req->timeout))
@@ -251,41 +326,72 @@ static void process_req(struct work_struct *work) 


	list_for_each_entry_safe(req, temp_req, &done_list, list) {

		list_del(&req->list);

		req->callback(req->status, &req->src_addr, req->addr,

			      req->context);

		req->callback(req->status, (struct sockaddr *) &req->src_addr,

			req->addr, req->context);

		put_client(req->client);

		kfree(req);

	}

}



static int addr_resolve_local(struct sockaddr_in *src_in,

			      struct sockaddr_in *dst_in,

static int addr_resolve_local(struct sockaddr *src_in,

			      struct sockaddr *dst_in,

			      struct rdma_dev_addr *addr)

{

	struct net_device *dev;

	__be32 src_ip = src_in->sin_addr.s_addr;

	__be32 dst_ip = dst_in->sin_addr.s_addr;

	int ret;



	if (dst_in->sa_family == AF_INET) {

		__be32 src_ip = ((struct sockaddr_in *) src_in)->sin_addr.s_addr;

		__be32 dst_ip = ((struct sockaddr_in *) dst_in)->sin_addr.s_addr;



		dev = ip_dev_find(&init_net, dst_ip);

		if (!dev)

			return -EADDRNOTAVAIL;



		if (ipv4_is_zeronet(src_ip)) {

		src_in->sin_family = dst_in->sin_family;

		src_in->sin_addr.s_addr = dst_ip;

			src_in->sa_family = dst_in->sa_family;

			((struct sockaddr_in *) src_in)->sin_addr.s_addr = dst_ip;

			ret = rdma_copy_addr(addr, dev, dev->dev_addr);

		} else if (ipv4_is_loopback(src_ip)) {

		ret = rdma_translate_ip((struct sockaddr *)dst_in, addr);

			ret = rdma_translate_ip(dst_in, addr);

			if (!ret)

				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);

		} else {

		ret = rdma_translate_ip((struct sockaddr *)src_in, addr);

			ret = rdma_translate_ip(src_in, addr);

			if (!ret)

				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);

		}



		dev_put(dev);

	} else {

		struct in6_addr *a;



		for_each_netdev(&init_net, dev)

			if (ipv6_chk_addr(&init_net,

					  &((struct sockaddr_in6 *) addr)->sin6_addr,

					  dev, 1))

				break;



		if (!dev)

			return -EADDRNOTAVAIL;



		a = &((struct sockaddr_in6 *) src_in)->sin6_addr;



		if (ipv6_addr_any(a)) {

			src_in->sa_family = dst_in->sa_family;

			((struct sockaddr_in6 *) src_in)->sin6_addr =

				((struct sockaddr_in6 *) dst_in)->sin6_addr;

			ret = rdma_copy_addr(addr, dev, dev->dev_addr);

		} else if (ipv6_addr_loopback(a)) {

			ret = rdma_translate_ip(dst_in, addr);

			if (!ret)

				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);

		} else  {

			ret = rdma_translate_ip(src_in, addr);

			if (!ret)

				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);

		}

	}



	return ret;

}
@@ -296,7 +402,7 @@ int rdma_resolve_ip(struct rdma_addr_client *client, 
				     struct rdma_dev_addr *addr, void *context),

		    void *context)

{

	struct sockaddr_in *src_in, *dst_in;

	struct sockaddr *src_in, *dst_in;

	struct addr_req *req;

	int ret = 0;
@@ -313,8 +419,8 @@ int rdma_resolve_ip(struct rdma_addr_client *client, 
	req->client = client;

	atomic_inc(&client->refcount);



	src_in = (struct sockaddr_in *) &req->src_addr;

	dst_in = (struct sockaddr_in *) &req->dst_addr;

	src_in = (struct sockaddr *) &req->src_addr;

	dst_in = (struct sockaddr *) &req->dst_addr;



	req->status = addr_resolve_local(src_in, dst_in, addr);

	if (req->status == -EADDRNOTAVAIL)

drivers/infiniband/core/cma.c

+60 −26
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ 
#include <linux/inetdevice.h>



#include <net/tcp.h>

#include <net/ipv6.h>



#include <rdma/rdma_cm.h>

#include <rdma/rdma_cm_ib.h>
@@ -636,7 +637,12 @@ static inline int cma_zero_addr(struct sockaddr *addr) 


static inline int cma_loopback_addr(struct sockaddr *addr)

{

	return ipv4_is_loopback(((struct sockaddr_in *) addr)->sin_addr.s_addr);

	if (addr->sa_family == AF_INET)

		return ipv4_is_loopback(

			((struct sockaddr_in *) addr)->sin_addr.s_addr);

	else

		return ipv6_addr_loopback(

			&((struct sockaddr_in6 *) addr)->sin6_addr);

}



static inline int cma_any_addr(struct sockaddr *addr)
@@ -1467,10 +1473,10 @@ static void cma_listen_on_all(struct rdma_id_private *id_priv) 


static int cma_bind_any(struct rdma_cm_id *id, sa_family_t af)

{

	struct sockaddr_in addr_in;

	struct sockaddr_storage addr_in;



	memset(&addr_in, 0, sizeof addr_in);

	addr_in.sin_family = af;

	addr_in.ss_family = af;

	return rdma_bind_addr(id, (struct sockaddr *) &addr_in);

}
@@ -2073,7 +2079,7 @@ int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr) 
	struct rdma_id_private *id_priv;

	int ret;



	if (addr->sa_family != AF_INET)

	if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6)

		return -EAFNOSUPPORT;



	id_priv = container_of(id, struct rdma_id_private, id);
@@ -2113,10 +2119,12 @@ EXPORT_SYMBOL(rdma_bind_addr); 
static int cma_format_hdr(void *hdr, enum rdma_port_space ps,

			  struct rdma_route *route)

{

	struct sockaddr_in *src4, *dst4;

	struct cma_hdr *cma_hdr;

	struct sdp_hh *sdp_hdr;



	if (route->addr.src_addr.ss_family == AF_INET) {

		struct sockaddr_in *src4, *dst4;



		src4 = (struct sockaddr_in *) &route->addr.src_addr;

		dst4 = (struct sockaddr_in *) &route->addr.dst_addr;
@@ -2139,6 +2147,32 @@ static int cma_format_hdr(void *hdr, enum rdma_port_space ps, 
			cma_hdr->port = src4->sin_port;

			break;

		}

	} else {

		struct sockaddr_in6 *src6, *dst6;



		src6 = (struct sockaddr_in6 *) &route->addr.src_addr;

		dst6 = (struct sockaddr_in6 *) &route->addr.dst_addr;



		switch (ps) {

		case RDMA_PS_SDP:

			sdp_hdr = hdr;

			if (sdp_get_majv(sdp_hdr->sdp_version) != SDP_MAJ_VERSION)

				return -EINVAL;

			sdp_set_ip_ver(sdp_hdr, 6);

			sdp_hdr->src_addr.ip6 = src6->sin6_addr;

			sdp_hdr->dst_addr.ip6 = dst6->sin6_addr;

			sdp_hdr->port = src6->sin6_port;

			break;

		default:

			cma_hdr = hdr;

			cma_hdr->cma_version = CMA_VERSION;

			cma_set_ip_ver(cma_hdr, 6);

			cma_hdr->src_addr.ip6 = src6->sin6_addr;

			cma_hdr->dst_addr.ip6 = dst6->sin6_addr;

			cma_hdr->port = src6->sin6_port;

			break;

		}

	}

	return 0;

}

drivers/infiniband/hw/ehca/ehca_classes.h

+7 −0
Original line number Diff line number Diff line
@@ -175,6 +175,13 @@ struct ehca_queue_map { 
	unsigned int next_wqe_idx;   /* Idx to first wqe to be flushed */

};



/* function to calculate the next index for the qmap */

static inline unsigned int next_index(unsigned int cur_index, unsigned int limit)

{

	unsigned int temp = cur_index + 1;

	return (temp == limit) ? 0 : temp;

}



struct ehca_qp {

	union {

		struct ib_qp ib_qp;

drivers/infiniband/hw/ehca/ehca_eq.c

+1 −1
Original line number Diff line number Diff line
@@ -113,7 +113,7 @@ int ehca_create_eq(struct ehca_shca *shca, 
			if (h_ret != H_SUCCESS || vpage)

				goto create_eq_exit2;

		} else {

			if (h_ret != H_PAGE_REGISTERED || !vpage)

			if (h_ret != H_PAGE_REGISTERED)

				goto create_eq_exit2;

		}

	}

drivers/infiniband/hw/ehca/ehca_main.c

+10 −7
Original line number Diff line number Diff line
@@ -717,6 +717,7 @@ static int __devinit ehca_probe(struct of_device *dev, 
	const u64 *handle;

	struct ib_pd *ibpd;

	int ret, i, eq_size;

	unsigned long flags;



	handle = of_get_property(dev->node, "ibm,hca-handle", NULL);

	if (!handle) {
@@ -830,9 +831,9 @@ static int __devinit ehca_probe(struct of_device *dev, 
		ehca_err(&shca->ib_device,

			 "Cannot create device attributes  ret=%d", ret);



	spin_lock(&shca_list_lock);

	spin_lock_irqsave(&shca_list_lock, flags);

	list_add(&shca->shca_list, &shca_list);

	spin_unlock(&shca_list_lock);

	spin_unlock_irqrestore(&shca_list_lock, flags);



	return 0;
@@ -878,6 +879,7 @@ static int __devinit ehca_probe(struct of_device *dev, 
static int __devexit ehca_remove(struct of_device *dev)

{

	struct ehca_shca *shca = dev->dev.driver_data;

	unsigned long flags;

	int ret;



	sysfs_remove_group(&dev->dev.kobj, &ehca_dev_attr_grp);
@@ -915,9 +917,9 @@ static int __devexit ehca_remove(struct of_device *dev) 


	ib_dealloc_device(&shca->ib_device);



	spin_lock(&shca_list_lock);

	spin_lock_irqsave(&shca_list_lock, flags);

	list_del(&shca->shca_list);

	spin_unlock(&shca_list_lock);

	spin_unlock_irqrestore(&shca_list_lock, flags);



	return ret;

}
@@ -975,6 +977,7 @@ static int ehca_mem_notifier(struct notifier_block *nb, 
			     unsigned long action, void *data)

{

	static unsigned long ehca_dmem_warn_time;

	unsigned long flags;



	switch (action) {

	case MEM_CANCEL_OFFLINE:
@@ -985,12 +988,12 @@ static int ehca_mem_notifier(struct notifier_block *nb, 
	case MEM_GOING_ONLINE:

	case MEM_GOING_OFFLINE:

		/* only ok if no hca is attached to the lpar */

		spin_lock(&shca_list_lock);

		spin_lock_irqsave(&shca_list_lock, flags);

		if (list_empty(&shca_list)) {

			spin_unlock(&shca_list_lock);

			spin_unlock_irqrestore(&shca_list_lock, flags);

			return NOTIFY_OK;

		} else {

			spin_unlock(&shca_list_lock);

			spin_unlock_irqrestore(&shca_list_lock, flags);

			if (printk_timed_ratelimit(&ehca_dmem_warn_time,

						   30 * 1000))

				ehca_gen_err("DMEM operations are not allowed"