2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
|
2005-08-11 08:03:10 +02:00
|
|
|
* Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
|
|
|
|
* Copyright (c) 2004 Voltaire, Inc. All rights reserved.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* General Public License (GPL) Version 2, available from the file
|
|
|
|
* COPYING in the main directory of this source tree, or the
|
|
|
|
* OpenIB.org BSD license below:
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or
|
|
|
|
* without modification, are permitted provided that the following
|
|
|
|
* conditions are met:
|
|
|
|
*
|
|
|
|
* - Redistributions of source code must retain the above
|
|
|
|
* copyright notice, this list of conditions and the following
|
|
|
|
* disclaimer.
|
|
|
|
*
|
|
|
|
* - Redistributions in binary form must reproduce the above
|
|
|
|
* copyright notice, this list of conditions and the following
|
|
|
|
* disclaimer in the documentation and/or other materials
|
|
|
|
* provided with the distribution.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*
|
|
|
|
* $Id: ipoib.h 1358 2004-12-17 22:00:11Z roland $
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _IPOIB_H
|
|
|
|
#define _IPOIB_H
|
|
|
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/kref.h>
|
|
|
|
#include <linux/if_infiniband.h>
|
2006-01-13 23:51:39 +01:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <net/neighbour.h>
|
|
|
|
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
|
2005-08-25 22:40:04 +02:00
|
|
|
#include <rdma/ib_verbs.h>
|
|
|
|
#include <rdma/ib_pack.h>
|
|
|
|
#include <rdma/ib_sa.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* constants */
|
|
|
|
|
|
|
|
enum {
|
|
|
|
IPOIB_PACKET_SIZE = 2048,
|
|
|
|
IPOIB_BUF_SIZE = IPOIB_PACKET_SIZE + IB_GRH_BYTES,
|
|
|
|
|
|
|
|
IPOIB_ENCAP_LEN = 4,
|
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
IPOIB_CM_MTU = 0x10000 - 0x10, /* padding to align header to 16 */
|
|
|
|
IPOIB_CM_BUF_SIZE = IPOIB_CM_MTU + IPOIB_ENCAP_LEN,
|
|
|
|
IPOIB_CM_HEAD_SIZE = IPOIB_CM_BUF_SIZE % PAGE_SIZE,
|
|
|
|
IPOIB_CM_RX_SG = ALIGN(IPOIB_CM_BUF_SIZE, PAGE_SIZE) / PAGE_SIZE,
|
2005-04-17 00:20:36 +02:00
|
|
|
IPOIB_RX_RING_SIZE = 128,
|
|
|
|
IPOIB_TX_RING_SIZE = 64,
|
2006-04-10 18:43:58 +02:00
|
|
|
IPOIB_MAX_QUEUE_SIZE = 8192,
|
|
|
|
IPOIB_MIN_QUEUE_SIZE = 2,
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
IPOIB_NUM_WC = 4,
|
|
|
|
|
|
|
|
IPOIB_MAX_PATH_REC_QUEUE = 3,
|
|
|
|
IPOIB_MAX_MCAST_QUEUE = 3,
|
|
|
|
|
|
|
|
IPOIB_FLAG_OPER_UP = 0,
|
2006-03-23 18:52:51 +01:00
|
|
|
IPOIB_FLAG_INITIALIZED = 1,
|
|
|
|
IPOIB_FLAG_ADMIN_UP = 2,
|
|
|
|
IPOIB_PKEY_ASSIGNED = 3,
|
|
|
|
IPOIB_PKEY_STOP = 4,
|
|
|
|
IPOIB_FLAG_SUBINTERFACE = 5,
|
|
|
|
IPOIB_MCAST_RUN = 6,
|
|
|
|
IPOIB_STOP_REAPER = 7,
|
|
|
|
IPOIB_MCAST_STARTED = 8,
|
2007-02-05 21:12:23 +01:00
|
|
|
IPOIB_FLAG_NETIF_STOPPED = 9,
|
|
|
|
IPOIB_FLAG_ADMIN_CM = 10,
|
IPoIB: Allow setting policy to ignore multicast groups
The kernel IB stack allows (through the RDMA CM) userspace
applications to join and use multicast groups from the IPoIB MGID
range. This allows multicast traffic to be handled directly from
userspace QPs, without going through the kernel stack, which gives
better performance for some applications.
However, to fully interoperate with IP multicast, such userspace
applications need to participate in IGMP reports and queries, or else
routers may not forward the multicast traffic to the system where the
application is running. The simplest way to do this is to share the
kernel IGMP implementation by using the IP_ADD_MEMBERSHIP option to
join multicast groups that are being handled directly in userspace.
However, in such cases, the actual multicast traffic should not also
be handled by the IPoIB interface, because that would burn resources
handling multicast packets that will just be discarded in the kernel.
To handle this, this patch adds lookup on the database used for IB
multicast group reference counting when IPoIB is joining multicast
groups, and if a multicast group is already handled by user space,
then the IPoIB kernel driver ignores the group. This is controlled by
a per-interface policy flag. When the flag is set, IPoIB will not
join and attach its QP to a multicast group which already has an entry
in the database; when the flag is cleared, IPoIB will behave as before
this change.
For each IPoIB interface, the /sys/class/net/$intf/umcast attribute
controls the policy flag. The default value is off/0.
Signed-off-by: Or Gerlitz <ogerlitz@voltaire.com>
Signed-off-by: Roland Dreier <rolandd@cisco.com>
2007-10-08 10:13:00 +02:00
|
|
|
IPOIB_FLAG_UMCAST = 11,
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
IPOIB_MAX_BACKOFF_SECONDS = 16,
|
|
|
|
|
|
|
|
IPOIB_MCAST_FLAG_FOUND = 0, /* used in set_multicast_list */
|
|
|
|
IPOIB_MCAST_FLAG_SENDONLY = 1,
|
|
|
|
IPOIB_MCAST_FLAG_BUSY = 2, /* joining or already joined */
|
|
|
|
IPOIB_MCAST_FLAG_ATTACHED = 3,
|
|
|
|
};
|
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
#define IPOIB_OP_RECV (1ul << 31)
|
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_CM
|
|
|
|
#define IPOIB_CM_OP_SRQ (1ul << 30)
|
|
|
|
#else
|
|
|
|
#define IPOIB_CM_OP_SRQ (0)
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* structs */
|
|
|
|
|
|
|
|
struct ipoib_header {
|
2005-08-14 06:05:57 +02:00
|
|
|
__be16 proto;
|
|
|
|
u16 reserved;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_pseudoheader {
|
|
|
|
u8 hwaddr[INFINIBAND_ALEN];
|
|
|
|
};
|
|
|
|
|
2007-08-02 21:21:31 +02:00
|
|
|
/* Used for all multicast joins (broadcast, IPv4 mcast and IPv6 mcast) */
|
|
|
|
struct ipoib_mcast {
|
|
|
|
struct ib_sa_mcmember_rec mcmember;
|
|
|
|
struct ib_sa_multicast *mc;
|
|
|
|
struct ipoib_ah *ah;
|
|
|
|
|
|
|
|
struct rb_node rb_node;
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
unsigned long created;
|
|
|
|
unsigned long backoff;
|
|
|
|
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned char logcount;
|
|
|
|
|
|
|
|
struct list_head neigh_list;
|
|
|
|
|
|
|
|
struct sk_buff_head pkt_queue;
|
|
|
|
|
|
|
|
struct net_device *dev;
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-29 00:30:34 +02:00
|
|
|
struct ipoib_rx_buf {
|
|
|
|
struct sk_buff *skb;
|
2006-12-12 23:30:48 +01:00
|
|
|
u64 mapping;
|
2005-10-29 00:30:34 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_tx_buf {
|
2005-04-17 00:20:36 +02:00
|
|
|
struct sk_buff *skb;
|
2006-12-12 23:30:48 +01:00
|
|
|
u64 mapping;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
struct ib_cm_id;
|
|
|
|
|
|
|
|
struct ipoib_cm_data {
|
|
|
|
__be32 qpn; /* High byte MUST be ignored on receive */
|
|
|
|
__be32 mtu;
|
|
|
|
};
|
|
|
|
|
2007-05-21 14:04:59 +02:00
|
|
|
/*
|
|
|
|
* Quoting 10.3.1 Queue Pair and EE Context States:
|
|
|
|
*
|
|
|
|
* Note, for QPs that are associated with an SRQ, the Consumer should take the
|
|
|
|
* QP through the Error State before invoking a Destroy QP or a Modify QP to the
|
|
|
|
* Reset State. The Consumer may invoke the Destroy QP without first performing
|
|
|
|
* a Modify QP to the Error State and waiting for the Affiliated Asynchronous
|
|
|
|
* Last WQE Reached Event. However, if the Consumer does not wait for the
|
|
|
|
* Affiliated Asynchronous Last WQE Reached Event, then WQE and Data Segment
|
|
|
|
* leakage may occur. Therefore, it is good programming practice to tear down a
|
|
|
|
* QP that is associated with an SRQ by using the following process:
|
|
|
|
*
|
|
|
|
* - Put the QP in the Error State
|
|
|
|
* - Wait for the Affiliated Asynchronous Last WQE Reached Event;
|
|
|
|
* - either:
|
|
|
|
* drain the CQ by invoking the Poll CQ verb and either wait for CQ
|
|
|
|
* to be empty or the number of Poll CQ operations has exceeded
|
|
|
|
* CQ capacity size;
|
|
|
|
* - or
|
|
|
|
* post another WR that completes on the same CQ and wait for this
|
|
|
|
* WR to return as a WC;
|
|
|
|
* - and then invoke a Destroy QP or Reset QP.
|
|
|
|
*
|
|
|
|
* We use the second option and wait for a completion on the
|
2007-05-28 13:37:27 +02:00
|
|
|
* same CQ before destroying QPs attached to our SRQ.
|
2007-05-21 14:04:59 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
enum ipoib_cm_state {
|
|
|
|
IPOIB_CM_RX_LIVE,
|
|
|
|
IPOIB_CM_RX_ERROR, /* Ignored by stale task */
|
|
|
|
IPOIB_CM_RX_FLUSH /* Last WQE Reached event observed */
|
|
|
|
};
|
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
struct ipoib_cm_rx {
|
|
|
|
struct ib_cm_id *id;
|
|
|
|
struct ib_qp *qp;
|
|
|
|
struct list_head list;
|
|
|
|
struct net_device *dev;
|
|
|
|
unsigned long jiffies;
|
2007-05-21 14:04:59 +02:00
|
|
|
enum ipoib_cm_state state;
|
2007-02-05 21:12:23 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_cm_tx {
|
|
|
|
struct ib_cm_id *id;
|
|
|
|
struct ib_cq *cq;
|
|
|
|
struct ib_qp *qp;
|
|
|
|
struct list_head list;
|
|
|
|
struct net_device *dev;
|
|
|
|
struct ipoib_neigh *neigh;
|
|
|
|
struct ipoib_path *path;
|
|
|
|
struct ipoib_tx_buf *tx_ring;
|
|
|
|
unsigned tx_head;
|
|
|
|
unsigned tx_tail;
|
|
|
|
unsigned long flags;
|
|
|
|
u32 mtu;
|
|
|
|
struct ib_wc ibwc[IPOIB_NUM_WC];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_cm_rx_buf {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
u64 mapping[IPOIB_CM_RX_SG];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_cm_dev_priv {
|
|
|
|
struct ib_srq *srq;
|
|
|
|
struct ipoib_cm_rx_buf *srq_ring;
|
|
|
|
struct ib_cm_id *id;
|
2007-05-21 14:04:59 +02:00
|
|
|
struct list_head passive_ids; /* state: LIVE */
|
|
|
|
struct list_head rx_error_list; /* state: ERROR */
|
|
|
|
struct list_head rx_flush_list; /* state: FLUSH, drain not started */
|
|
|
|
struct list_head rx_drain_list; /* state: FLUSH, drain started */
|
|
|
|
struct list_head rx_reap_list; /* state: FLUSH, drain done */
|
2007-02-05 21:12:23 +01:00
|
|
|
struct work_struct start_task;
|
|
|
|
struct work_struct reap_task;
|
|
|
|
struct work_struct skb_task;
|
2007-05-21 14:04:59 +02:00
|
|
|
struct work_struct rx_reap_task;
|
2007-02-05 21:12:23 +01:00
|
|
|
struct delayed_work stale_task;
|
|
|
|
struct sk_buff_head skb_queue;
|
|
|
|
struct list_head start_list;
|
|
|
|
struct list_head reap_list;
|
|
|
|
struct ib_wc ibwc[IPOIB_NUM_WC];
|
|
|
|
struct ib_sge rx_sge[IPOIB_CM_RX_SG];
|
|
|
|
struct ib_recv_wr rx_wr;
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Device private locking: tx_lock protects members used in TX fast
|
|
|
|
* path (and we use LLTX so upper layers don't do extra locking).
|
|
|
|
* lock protects everything else. lock nests inside of tx_lock (ie
|
|
|
|
* tx_lock must be acquired first if needed).
|
|
|
|
*/
|
|
|
|
struct ipoib_dev_priv {
|
|
|
|
spinlock_t lock;
|
|
|
|
|
|
|
|
struct net_device *dev;
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 01:41:36 +02:00
|
|
|
struct napi_struct napi;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-01-13 23:51:39 +01:00
|
|
|
struct mutex mcast_mutex;
|
|
|
|
struct mutex vlan_mutex;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
struct rb_root path_tree;
|
|
|
|
struct list_head path_list;
|
|
|
|
|
|
|
|
struct ipoib_mcast *broadcast;
|
|
|
|
struct list_head multicast_list;
|
|
|
|
struct rb_root multicast_tree;
|
|
|
|
|
2007-05-19 17:51:54 +02:00
|
|
|
struct delayed_work pkey_poll_task;
|
2006-11-22 15:57:56 +01:00
|
|
|
struct delayed_work mcast_task;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct work_struct flush_task;
|
|
|
|
struct work_struct restart_task;
|
2006-11-22 15:57:56 +01:00
|
|
|
struct delayed_work ah_reap_task;
|
2007-05-19 17:51:54 +02:00
|
|
|
struct work_struct pkey_event_task;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
struct ib_device *ca;
|
|
|
|
u8 port;
|
|
|
|
u16 pkey;
|
2007-05-19 17:51:54 +02:00
|
|
|
u16 pkey_index;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct ib_pd *pd;
|
|
|
|
struct ib_mr *mr;
|
|
|
|
struct ib_cq *cq;
|
|
|
|
struct ib_qp *qp;
|
|
|
|
u32 qkey;
|
|
|
|
|
|
|
|
union ib_gid local_gid;
|
|
|
|
u16 local_lid;
|
|
|
|
|
|
|
|
unsigned int admin_mtu;
|
|
|
|
unsigned int mcast_mtu;
|
|
|
|
|
2005-10-29 00:30:34 +02:00
|
|
|
struct ipoib_rx_buf *rx_ring;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-29 00:30:34 +02:00
|
|
|
spinlock_t tx_lock;
|
|
|
|
struct ipoib_tx_buf *tx_ring;
|
|
|
|
unsigned tx_head;
|
|
|
|
unsigned tx_tail;
|
|
|
|
struct ib_sge tx_sge;
|
|
|
|
struct ib_send_wr tx_wr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
struct ib_wc ibwc[IPOIB_NUM_WC];
|
|
|
|
|
|
|
|
struct list_head dead_ahs;
|
|
|
|
|
|
|
|
struct ib_event_handler event_handler;
|
|
|
|
|
|
|
|
struct net_device *parent;
|
|
|
|
struct list_head child_intfs;
|
|
|
|
struct list_head list;
|
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_CM
|
|
|
|
struct ipoib_cm_dev_priv cm;
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
|
|
|
|
struct list_head fs_list;
|
|
|
|
struct dentry *mcg_dentry;
|
2005-11-07 19:33:11 +01:00
|
|
|
struct dentry *path_dentry;
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_ah {
|
|
|
|
struct net_device *dev;
|
|
|
|
struct ib_ah *ah;
|
|
|
|
struct list_head list;
|
|
|
|
struct kref ref;
|
|
|
|
unsigned last_send;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_path {
|
|
|
|
struct net_device *dev;
|
|
|
|
struct ib_sa_path_rec pathrec;
|
|
|
|
struct ipoib_ah *ah;
|
|
|
|
struct sk_buff_head queue;
|
|
|
|
|
|
|
|
struct list_head neigh_list;
|
|
|
|
|
|
|
|
int query_id;
|
|
|
|
struct ib_sa_query *query;
|
|
|
|
struct completion done;
|
|
|
|
|
|
|
|
struct rb_node rb_node;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipoib_neigh {
|
|
|
|
struct ipoib_ah *ah;
|
2007-02-05 21:12:23 +01:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_CM
|
|
|
|
struct ipoib_cm_tx *cm;
|
|
|
|
#endif
|
2006-07-19 16:44:37 +02:00
|
|
|
union ib_gid dgid;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct sk_buff_head queue;
|
|
|
|
|
|
|
|
struct neighbour *neighbour;
|
|
|
|
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2006-02-21 06:50:39 +01:00
|
|
|
/*
|
|
|
|
* We stash a pointer to our private neighbour information after our
|
|
|
|
* hardware address in neigh->ha. The ALIGN() expression here makes
|
|
|
|
* sure that this pointer is stored aligned so that an unaligned
|
|
|
|
* load is not needed to dereference it.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline struct ipoib_neigh **to_ipoib_neigh(struct neighbour *neigh)
|
|
|
|
{
|
2006-02-21 06:50:39 +01:00
|
|
|
return (void*) neigh + ALIGN(offsetof(struct neighbour, ha) +
|
|
|
|
INFINIBAND_ALEN, sizeof(void *));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-04-04 18:59:40 +02:00
|
|
|
struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neigh);
|
2006-11-16 13:16:47 +01:00
|
|
|
void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh);
|
2006-04-04 18:59:40 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
extern struct workqueue_struct *ipoib_workqueue;
|
|
|
|
|
|
|
|
/* functions */
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 01:41:36 +02:00
|
|
|
int ipoib_poll(struct napi_struct *napi, int budget);
|
2005-04-17 00:20:36 +02:00
|
|
|
void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr);
|
|
|
|
|
|
|
|
struct ipoib_ah *ipoib_create_ah(struct net_device *dev,
|
|
|
|
struct ib_pd *pd, struct ib_ah_attr *attr);
|
|
|
|
void ipoib_free_ah(struct kref *kref);
|
|
|
|
static inline void ipoib_put_ah(struct ipoib_ah *ah)
|
|
|
|
{
|
|
|
|
kref_put(&ah->ref, ipoib_free_ah);
|
|
|
|
}
|
|
|
|
|
2005-11-03 05:51:01 +01:00
|
|
|
int ipoib_open(struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
int ipoib_add_pkey_attr(struct net_device *dev);
|
IPoIB: Allow setting policy to ignore multicast groups
The kernel IB stack allows (through the RDMA CM) userspace
applications to join and use multicast groups from the IPoIB MGID
range. This allows multicast traffic to be handled directly from
userspace QPs, without going through the kernel stack, which gives
better performance for some applications.
However, to fully interoperate with IP multicast, such userspace
applications need to participate in IGMP reports and queries, or else
routers may not forward the multicast traffic to the system where the
application is running. The simplest way to do this is to share the
kernel IGMP implementation by using the IP_ADD_MEMBERSHIP option to
join multicast groups that are being handled directly in userspace.
However, in such cases, the actual multicast traffic should not also
be handled by the IPoIB interface, because that would burn resources
handling multicast packets that will just be discarded in the kernel.
To handle this, this patch adds lookup on the database used for IB
multicast group reference counting when IPoIB is joining multicast
groups, and if a multicast group is already handled by user space,
then the IPoIB kernel driver ignores the group. This is controlled by
a per-interface policy flag. When the flag is set, IPoIB will not
join and attach its QP to a multicast group which already has an entry
in the database; when the flag is cleared, IPoIB will behave as before
this change.
For each IPoIB interface, the /sys/class/net/$intf/umcast attribute
controls the policy flag. The default value is off/0.
Signed-off-by: Or Gerlitz <ogerlitz@voltaire.com>
Signed-off-by: Roland Dreier <rolandd@cisco.com>
2007-10-08 10:13:00 +02:00
|
|
|
int ipoib_add_umcast_attr(struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
void ipoib_send(struct net_device *dev, struct sk_buff *skb,
|
|
|
|
struct ipoib_ah *address, u32 qpn);
|
2006-11-22 15:57:56 +01:00
|
|
|
void ipoib_reap_ah(struct work_struct *work);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
void ipoib_flush_paths(struct net_device *dev);
|
|
|
|
struct ipoib_dev_priv *ipoib_intf_alloc(const char *format);
|
|
|
|
|
|
|
|
int ipoib_ib_dev_init(struct net_device *dev, struct ib_device *ca, int port);
|
2006-11-22 15:57:56 +01:00
|
|
|
void ipoib_ib_dev_flush(struct work_struct *work);
|
2007-05-19 17:51:54 +02:00
|
|
|
void ipoib_pkey_event(struct work_struct *work);
|
2005-04-17 00:20:36 +02:00
|
|
|
void ipoib_ib_dev_cleanup(struct net_device *dev);
|
|
|
|
|
|
|
|
int ipoib_ib_dev_open(struct net_device *dev);
|
|
|
|
int ipoib_ib_dev_up(struct net_device *dev);
|
2006-03-20 19:08:24 +01:00
|
|
|
int ipoib_ib_dev_down(struct net_device *dev, int flush);
|
2007-05-19 17:51:54 +02:00
|
|
|
int ipoib_ib_dev_stop(struct net_device *dev, int flush);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port);
|
|
|
|
void ipoib_dev_cleanup(struct net_device *dev);
|
|
|
|
|
2006-11-22 15:57:56 +01:00
|
|
|
void ipoib_mcast_join_task(struct work_struct *work);
|
2006-05-29 18:14:05 +02:00
|
|
|
void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-22 15:57:56 +01:00
|
|
|
void ipoib_mcast_restart_task(struct work_struct *work);
|
2005-04-17 00:20:36 +02:00
|
|
|
int ipoib_mcast_start_thread(struct net_device *dev);
|
2005-09-20 19:52:04 +02:00
|
|
|
int ipoib_mcast_stop_thread(struct net_device *dev, int flush);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
void ipoib_mcast_dev_down(struct net_device *dev);
|
|
|
|
void ipoib_mcast_dev_flush(struct net_device *dev);
|
|
|
|
|
2005-11-03 05:51:01 +01:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
|
2005-04-17 00:20:36 +02:00
|
|
|
struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev);
|
|
|
|
int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter);
|
|
|
|
void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,
|
|
|
|
union ib_gid *gid,
|
|
|
|
unsigned long *created,
|
|
|
|
unsigned int *queuelen,
|
|
|
|
unsigned int *complete,
|
|
|
|
unsigned int *send_only);
|
2005-11-07 19:33:11 +01:00
|
|
|
|
|
|
|
struct ipoib_path_iter *ipoib_path_iter_init(struct net_device *dev);
|
|
|
|
int ipoib_path_iter_next(struct ipoib_path_iter *iter);
|
|
|
|
void ipoib_path_iter_read(struct ipoib_path_iter *iter,
|
|
|
|
struct ipoib_path *path);
|
2005-11-03 05:51:01 +01:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
int ipoib_mcast_attach(struct net_device *dev, u16 mlid,
|
|
|
|
union ib_gid *mgid);
|
|
|
|
int ipoib_mcast_detach(struct net_device *dev, u16 mlid,
|
|
|
|
union ib_gid *mgid);
|
|
|
|
|
2005-10-11 20:08:24 +02:00
|
|
|
int ipoib_init_qp(struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca);
|
|
|
|
void ipoib_transport_dev_cleanup(struct net_device *dev);
|
|
|
|
|
|
|
|
void ipoib_event(struct ib_event_handler *handler,
|
|
|
|
struct ib_event *record);
|
|
|
|
|
|
|
|
int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey);
|
|
|
|
int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey);
|
|
|
|
|
2006-11-22 15:57:56 +01:00
|
|
|
void ipoib_pkey_poll(struct work_struct *work);
|
2005-04-17 00:20:36 +02:00
|
|
|
int ipoib_pkey_dev_delay_open(struct net_device *dev);
|
2007-05-24 17:32:46 +02:00
|
|
|
void ipoib_drain_cq(struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_CM
|
|
|
|
|
|
|
|
#define IPOIB_FLAGS_RC 0x80
|
|
|
|
#define IPOIB_FLAGS_UC 0x40
|
|
|
|
|
|
|
|
/* We don't support UC connections at the moment */
|
|
|
|
#define IPOIB_CM_SUPPORTED(ha) (ha[0] & (IPOIB_FLAGS_RC))
|
|
|
|
|
|
|
|
static inline int ipoib_cm_admin_enabled(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ipoib_dev_priv *priv = netdev_priv(dev);
|
|
|
|
return IPOIB_CM_SUPPORTED(dev->dev_addr) &&
|
|
|
|
test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)
|
|
|
|
{
|
|
|
|
struct ipoib_dev_priv *priv = netdev_priv(dev);
|
|
|
|
return IPOIB_CM_SUPPORTED(n->ha) &&
|
|
|
|
test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ipoib_cm_up(struct ipoib_neigh *neigh)
|
|
|
|
|
|
|
|
{
|
|
|
|
return test_bit(IPOIB_FLAG_OPER_UP, &neigh->cm->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct ipoib_cm_tx *ipoib_cm_get(struct ipoib_neigh *neigh)
|
|
|
|
{
|
|
|
|
return neigh->cm;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ipoib_cm_set(struct ipoib_neigh *neigh, struct ipoib_cm_tx *tx)
|
|
|
|
{
|
|
|
|
neigh->cm = tx;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_tx *tx);
|
|
|
|
int ipoib_cm_dev_open(struct net_device *dev);
|
|
|
|
void ipoib_cm_dev_stop(struct net_device *dev);
|
|
|
|
int ipoib_cm_dev_init(struct net_device *dev);
|
|
|
|
int ipoib_cm_add_mode_attr(struct net_device *dev);
|
|
|
|
void ipoib_cm_dev_cleanup(struct net_device *dev);
|
|
|
|
struct ipoib_cm_tx *ipoib_cm_create_tx(struct net_device *dev, struct ipoib_path *path,
|
|
|
|
struct ipoib_neigh *neigh);
|
|
|
|
void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx);
|
|
|
|
void ipoib_cm_skb_too_long(struct net_device* dev, struct sk_buff *skb,
|
|
|
|
unsigned int mtu);
|
|
|
|
void ipoib_cm_handle_rx_wc(struct net_device *dev, struct ib_wc *wc);
|
|
|
|
#else
|
|
|
|
|
|
|
|
struct ipoib_cm_tx;
|
|
|
|
|
|
|
|
static inline int ipoib_cm_admin_enabled(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)
|
|
|
|
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ipoib_cm_up(struct ipoib_neigh *neigh)
|
|
|
|
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct ipoib_cm_tx *ipoib_cm_get(struct ipoib_neigh *neigh)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ipoib_cm_set(struct ipoib_neigh *neigh, struct ipoib_cm_tx *tx)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_tx *tx)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
int ipoib_cm_dev_open(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void ipoib_cm_dev_stop(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
int ipoib_cm_dev_init(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void ipoib_cm_dev_cleanup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
struct ipoib_cm_tx *ipoib_cm_create_tx(struct net_device *dev, struct ipoib_path *path,
|
|
|
|
struct ipoib_neigh *neigh)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
int ipoib_cm_add_mode_attr(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ipoib_cm_skb_too_long(struct net_device* dev, struct sk_buff *skb,
|
|
|
|
unsigned int mtu)
|
|
|
|
{
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ipoib_cm_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
|
2005-11-07 19:33:11 +01:00
|
|
|
void ipoib_create_debug_files(struct net_device *dev);
|
|
|
|
void ipoib_delete_debug_files(struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
int ipoib_register_debugfs(void);
|
|
|
|
void ipoib_unregister_debugfs(void);
|
|
|
|
#else
|
2005-11-07 19:33:11 +01:00
|
|
|
static inline void ipoib_create_debug_files(struct net_device *dev) { }
|
|
|
|
static inline void ipoib_delete_debug_files(struct net_device *dev) { }
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline int ipoib_register_debugfs(void) { return 0; }
|
|
|
|
static inline void ipoib_unregister_debugfs(void) { }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#define ipoib_printk(level, priv, format, arg...) \
|
|
|
|
printk(level "%s: " format, ((struct ipoib_dev_priv *) priv)->dev->name , ## arg)
|
|
|
|
#define ipoib_warn(priv, format, arg...) \
|
|
|
|
ipoib_printk(KERN_WARNING, priv, format , ## arg)
|
|
|
|
|
2006-04-10 18:43:58 +02:00
|
|
|
extern int ipoib_sendq_size;
|
|
|
|
extern int ipoib_recvq_size;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-22 01:40:12 +02:00
|
|
|
extern struct ib_sa_client ipoib_sa_client;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
|
|
|
|
extern int ipoib_debug_level;
|
|
|
|
|
|
|
|
#define ipoib_dbg(priv, format, arg...) \
|
|
|
|
do { \
|
|
|
|
if (ipoib_debug_level > 0) \
|
|
|
|
ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
|
|
|
|
} while (0)
|
|
|
|
#define ipoib_dbg_mcast(priv, format, arg...) \
|
|
|
|
do { \
|
|
|
|
if (mcast_debug_level > 0) \
|
|
|
|
ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
|
|
|
|
} while (0)
|
|
|
|
#else /* CONFIG_INFINIBAND_IPOIB_DEBUG */
|
|
|
|
#define ipoib_dbg(priv, format, arg...) \
|
|
|
|
do { (void) (priv); } while (0)
|
|
|
|
#define ipoib_dbg_mcast(priv, format, arg...) \
|
|
|
|
do { (void) (priv); } while (0)
|
|
|
|
#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */
|
|
|
|
|
|
|
|
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG_DATA
|
|
|
|
#define ipoib_dbg_data(priv, format, arg...) \
|
|
|
|
do { \
|
|
|
|
if (data_debug_level > 0) \
|
|
|
|
ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
|
|
|
|
} while (0)
|
|
|
|
#else /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */
|
|
|
|
#define ipoib_dbg_data(priv, format, arg...) \
|
|
|
|
do { (void) (priv); } while (0)
|
|
|
|
#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */
|
|
|
|
|
|
|
|
|
2006-05-29 18:14:05 +02:00
|
|
|
#define IPOIB_GID_FMT "%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:" \
|
|
|
|
"%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x"
|
|
|
|
|
|
|
|
#define IPOIB_GID_RAW_ARG(gid) ((u8 *)(gid))[0], \
|
|
|
|
((u8 *)(gid))[1], \
|
|
|
|
((u8 *)(gid))[2], \
|
|
|
|
((u8 *)(gid))[3], \
|
|
|
|
((u8 *)(gid))[4], \
|
|
|
|
((u8 *)(gid))[5], \
|
|
|
|
((u8 *)(gid))[6], \
|
|
|
|
((u8 *)(gid))[7], \
|
|
|
|
((u8 *)(gid))[8], \
|
|
|
|
((u8 *)(gid))[9], \
|
|
|
|
((u8 *)(gid))[10],\
|
|
|
|
((u8 *)(gid))[11],\
|
|
|
|
((u8 *)(gid))[12],\
|
|
|
|
((u8 *)(gid))[13],\
|
|
|
|
((u8 *)(gid))[14],\
|
|
|
|
((u8 *)(gid))[15]
|
|
|
|
|
|
|
|
#define IPOIB_GID_ARG(gid) IPOIB_GID_RAW_ARG((gid).raw)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-05 21:12:23 +01:00
|
|
|
#define IPOIB_QPN(ha) (be32_to_cpup((__be32 *) ha) & 0xffffff)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif /* _IPOIB_H */
|