* Re: [PATCH net-next V1 7/9] net/eipoib: Add main driver functionality
From: Ben Hutchings @ 2012-07-19 16:16 UTC (permalink / raw)
To: Or Gerlitz; +Cc: davem, roland, netdev, ali, sean.hefty, shlomop, Erez Shitrit
In-Reply-To: <50082BDE.2040005@mellanox.com>
On Thu, 2012-07-19 at 18:46 +0300, Or Gerlitz wrote:
> On 7/19/2012 4:49 PM, Ben Hutchings wrote:
> > On Wed, 2012-07-18 at 14:00 +0300, Or Gerlitz wrote:
[...]
> >> + .ndo_vlan_rx_add_vid = eth_ipoib_vlan_rx_add_vid,
> >> + .ndo_vlan_rx_kill_vid = eth_ipoib_vlan_rx_kill_vid,
> >
> > These shouldn't be needed.
>
> ok, here's the point, the eIPoIB driver maps Ethernet vlans to
> infiniband/IPoIB pkeys
> (partition keys). The underlying IPoIB devices work with these pkeys
> in a way which is HW accelerated, and we want the eIPoIB driver to be
> considered as one
> that support HW accelerate vlans. E.g on the TX flow we don't want that
> any special SW
> handling by the 8021q driver will be done on the skb except for setting
> the skb->vlan_tci
> field, and in the RX flow, we set skb->vlan_tci field and don't want
> that 8021q to try
> and extract it from the headers, etc.
>
> For that end, I was under the impression all the three
> NETIF_F_HW_VLAN_{TX,RX,FILTER)
> features need to be advertized. From your comment I understand now that
> RX/TX are enough
> in that respect?
[...]
Yes.
Ben.
--
Ben Hutchings, Staff Engineer, Solarflare
Not speaking for my employer; that's the marketing department's job.
They asked us to note that Solarflare product names are trademarked.
^ permalink raw reply
* [PATCH RESEND net/for-next V1 1/1] IB/ipoib: break linkage to neighbouring system
From: Or Gerlitz @ 2012-07-19 16:15 UTC (permalink / raw)
To: roland, davem; +Cc: linux-rdma, erezsh, netdev, Shlomo Pongratz, Or Gerlitz
In-Reply-To: <1342714502-11301-1-git-send-email-ogerlitz@mellanox.com>
From: Shlomo Pongratz <shlomop@mellanox.com>
Dave Miller <davem@davemloft.net> provided a detailed description of why the
way IPoIB is using neighbours for its own ipoib_neigh struct is buggy:
Any time an ipoib_neigh is changed, a sequence like the following is made:
spin_lock_irqsave(&priv->lock, flags);
/*
* It's safe to call ipoib_put_ah() inside
* priv->lock here, because we know that
* path->ah will always hold one more reference,
* so ipoib_put_ah() will never do more than
* decrement the ref count.
*/
if (neigh->ah)
ipoib_put_ah(neigh->ah);
list_del(&neigh->list);
ipoib_neigh_free(dev, neigh);
spin_unlock_irqrestore(&priv->lock, flags);
ipoib_path_lookup(skb, n, dev);
This doesn't work, because you're leaving a stale pointer to the freed up
ipoib_neigh in the special neigh->ha pointer cookie. Yes, it even fails
with all the locking done to protect _changes_ to *ipoib_neigh(n), and
with the code in ipoib_neigh_free() that NULLs out the pointer.
The core issue is that read side calls to *to_ipoib_neigh(n) are not
being synchronized at all, they are performed without any locking. So
whether we hold the lock or not when making changes to *ipoib_neigh(n)
you still can have threads see references to freed up ipoib_neigh
objects.
cpu 1 cpu 2
n = *ipoib_neigh()
*ipoib_neigh() = NULL
kfree(n)
n->foo == OOPS
[..]
Perhaps the ipoib code can have a private path database it manages
entirely itself, which holds all the necessary information and is
looked up by some generic key which is available easily at transmit
time and does not involve generic neighbour entries. -- end of quote
See here http://marc.info/?l=linux-rdma&m=132812793105624&w=2 the note, full discussion
http://marc.info/?l=linux-rdma&w=2&r=1&s=allows+references+to+freed+memory&q=b
This patch aims to solve the race conditions found in the IPoIB driver.
The patch breaks the connection between the core networking neighbour structure
and the ipoib_neigh structure. Except for avoiding the race, it allows to in
under a setup where SKBs carrying IP packets that don't have any associated
neighbour are transmitted through IPoIB.
We add an ipoib_neigh hash table with 1024 buckets. The hash table key is the destination
hardware address. Thus the ipoib_neigh is fetched from the hash table and not
dereferenced from the stashed location at the neighbour structure. The hash table uses
both RCU and reference count mechanisms to guarantee that no ipoib_neigh instance is
ever deleted while in use.
Fetching the ipoib_neigh structure instance from the hash also makes the special
code in ipoib_start_xmit that handles remote and local bonding failover redundant.
Aged ipoib_neigh instances are deleted by a garbage collection task that runs every
30 seconds and deletes every ipoib_neigh instance that was idle for at least 60
seconds. The deletion is safe since the ipoib_neigh instances are protected
using RCU and reference count mechanisms.
Signed-off-by: Shlomo Pongratz <shlomop@mellanox.com>
Signed-off-by: Or Gerlitz <ogerlitz@mellanox.com>
---
drivers/infiniband/ulp/ipoib/ipoib.h | 59 ++-
drivers/infiniband/ulp/ipoib/ipoib_cm.c | 16 +-
drivers/infiniband/ulp/ipoib/ipoib_main.c | 638 +++++++++++++++++------
drivers/infiniband/ulp/ipoib/ipoib_multicast.c | 57 +--
4 files changed, 535 insertions(+), 235 deletions(-)
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index 86df632..ea765e1 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -92,6 +92,8 @@ enum {
IPOIB_STOP_REAPER = 7,
IPOIB_FLAG_ADMIN_CM = 9,
IPOIB_FLAG_UMCAST = 10,
+ IPOIB_STOP_NEIGH_GC = 11,
+ IPOIB_NEIGH_TBL_FLUSH = 12,
IPOIB_MAX_BACKOFF_SECONDS = 16,
@@ -260,6 +262,25 @@ struct ipoib_ethtool_st {
u16 max_coalesced_frames;
};
+enum {
+ IPOIB_NEIGH_LOG_INIT_SIZE = 10,
+ IPOIB_NEIGH_GC_SEC = 30
+};
+
+struct ipoib_neigh_hash {
+ struct ipoib_neigh __rcu **buckets;
+ struct rcu_head rcu;
+ u32 mask;
+ u32 size;
+};
+
+struct ipoib_neigh_table {
+ struct ipoib_neigh_hash __rcu *htbl;
+ rwlock_t rwlock;
+ atomic_t entries;
+ struct completion flushed;
+};
+
/*
* Device private locking: network stack tx_lock protects members used
* in TX fast path, lock protects everything else. lock nests inside
@@ -279,6 +300,8 @@ struct ipoib_dev_priv {
struct rb_root path_tree;
struct list_head path_list;
+ struct ipoib_neigh_table ntbl;
+
struct ipoib_mcast *broadcast;
struct list_head multicast_list;
struct rb_root multicast_tree;
@@ -291,7 +314,7 @@ struct ipoib_dev_priv {
struct work_struct flush_heavy;
struct work_struct restart_task;
struct delayed_work ah_reap_task;
-
+ struct delayed_work neigh_reap_task;
struct ib_device *ca;
u8 port;
u16 pkey;
@@ -377,13 +400,16 @@ struct ipoib_neigh {
#ifdef CONFIG_INFINIBAND_IPOIB_CM
struct ipoib_cm_tx *cm;
#endif
- union ib_gid dgid;
+ u8 daddr[INFINIBAND_ALEN];
struct sk_buff_head queue;
- struct neighbour *neighbour;
struct net_device *dev;
struct list_head list;
+ struct ipoib_neigh __rcu *hnext;
+ struct rcu_head rcu;
+ atomic_t refcnt;
+ unsigned long alive;
};
#define IPOIB_UD_MTU(ib_mtu) (ib_mtu - IPOIB_ENCAP_LEN)
@@ -394,21 +420,17 @@ static inline int ipoib_ud_need_sg(unsigned int ib_mtu)
return IPOIB_UD_BUF_SIZE(ib_mtu) > PAGE_SIZE;
}
-/*
- * 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.
- */
-static inline struct ipoib_neigh **to_ipoib_neigh(struct neighbour *neigh)
+void ipoib_neigh_dtor(struct ipoib_neigh *neigh);
+static inline void ipoib_neigh_put(struct ipoib_neigh *neigh)
{
- return (void*) neigh + ALIGN(offsetof(struct neighbour, ha) +
- INFINIBAND_ALEN, sizeof(void *));
+ if (atomic_dec_and_test(&neigh->refcnt))
+ ipoib_neigh_dtor(neigh);
}
-
-struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neigh,
+struct ipoib_neigh *ipoib_neigh_get(struct net_device *dev, u8 *daddr);
+struct ipoib_neigh *ipoib_neigh_alloc(u8 *daddr,
struct net_device *dev);
-void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh);
+void ipoib_neigh_free(struct ipoib_neigh *neigh);
+void ipoib_del_neighs_by_gid(struct net_device *dev, u8 *gid);
extern struct workqueue_struct *ipoib_workqueue;
@@ -425,7 +447,6 @@ static inline void ipoib_put_ah(struct ipoib_ah *ah)
{
kref_put(&ah->ref, ipoib_free_ah);
}
-
int ipoib_open(struct net_device *dev);
int ipoib_add_pkey_attr(struct net_device *dev);
int ipoib_add_umcast_attr(struct net_device *dev);
@@ -455,7 +476,7 @@ void ipoib_dev_cleanup(struct net_device *dev);
void ipoib_mcast_join_task(struct work_struct *work);
void ipoib_mcast_carrier_on_task(struct work_struct *work);
-void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb);
+void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb);
void ipoib_mcast_restart_task(struct work_struct *work);
int ipoib_mcast_start_thread(struct net_device *dev);
@@ -517,10 +538,10 @@ static inline int ipoib_cm_admin_enabled(struct net_device *dev)
test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
}
-static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)
+static inline int ipoib_cm_enabled(struct net_device *dev, u8 *hwaddr)
{
struct ipoib_dev_priv *priv = netdev_priv(dev);
- return IPOIB_CM_SUPPORTED(n->ha) &&
+ return IPOIB_CM_SUPPORTED(hwaddr) &&
test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
}
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_cm.c b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
index 1ca7322..19bc95a 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_cm.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
@@ -811,9 +811,7 @@ void ipoib_cm_handle_tx_wc(struct net_device *dev, struct ib_wc *wc)
if (neigh) {
neigh->cm = NULL;
list_del(&neigh->list);
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- ipoib_neigh_free(dev, neigh);
+ ipoib_neigh_free(neigh);
tx->neigh = NULL;
}
@@ -1230,9 +1228,7 @@ static int ipoib_cm_tx_handler(struct ib_cm_id *cm_id,
if (neigh) {
neigh->cm = NULL;
list_del(&neigh->list);
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- ipoib_neigh_free(dev, neigh);
+ ipoib_neigh_free(neigh);
tx->neigh = NULL;
}
@@ -1279,7 +1275,7 @@ void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx)
list_move(&tx->list, &priv->cm.reap_list);
queue_work(ipoib_workqueue, &priv->cm.reap_task);
ipoib_dbg(priv, "Reap connection for gid %pI6\n",
- tx->neigh->dgid.raw);
+ tx->neigh->daddr + 4);
tx->neigh = NULL;
}
}
@@ -1304,7 +1300,7 @@ static void ipoib_cm_tx_start(struct work_struct *work)
p = list_entry(priv->cm.start_list.next, typeof(*p), list);
list_del_init(&p->list);
neigh = p->neigh;
- qpn = IPOIB_QPN(neigh->neighbour->ha);
+ qpn = IPOIB_QPN(neigh->daddr);
memcpy(&pathrec, &p->path->pathrec, sizeof pathrec);
spin_unlock_irqrestore(&priv->lock, flags);
@@ -1320,9 +1316,7 @@ static void ipoib_cm_tx_start(struct work_struct *work)
if (neigh) {
neigh->cm = NULL;
list_del(&neigh->list);
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- ipoib_neigh_free(dev, neigh);
+ ipoib_neigh_free(neigh);
}
list_del(&p->list);
kfree(p);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index bbee4b2..d07c7b9 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -46,7 +46,7 @@
#include <linux/ip.h>
#include <linux/in.h>
-#include <net/dst.h>
+#include <linux/jhash.h>
MODULE_AUTHOR("Roland Dreier");
MODULE_DESCRIPTION("IP-over-InfiniBand net driver");
@@ -84,6 +84,7 @@ struct ib_sa_client ipoib_sa_client;
static void ipoib_add_one(struct ib_device *device);
static void ipoib_remove_one(struct ib_device *device);
+static void ipoib_neigh_reclaim(struct rcu_head *rp);
static struct ib_client ipoib_client = {
.name = "ipoib",
@@ -264,30 +265,15 @@ static int __path_add(struct net_device *dev, struct ipoib_path *path)
static void path_free(struct net_device *dev, struct ipoib_path *path)
{
- struct ipoib_dev_priv *priv = netdev_priv(dev);
- struct ipoib_neigh *neigh, *tn;
struct sk_buff *skb;
- unsigned long flags;
while ((skb = __skb_dequeue(&path->queue)))
dev_kfree_skb_irq(skb);
- spin_lock_irqsave(&priv->lock, flags);
-
- list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) {
- /*
- * It's safe to call ipoib_put_ah() inside priv->lock
- * here, because we know that path->ah will always
- * hold one more reference, so ipoib_put_ah() will
- * never do more than decrement the ref count.
- */
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
-
- ipoib_neigh_free(dev, neigh);
- }
+ ipoib_dbg(netdev_priv(dev), "path_free\n");
- spin_unlock_irqrestore(&priv->lock, flags);
+ /* remove all neigh connected to this path */
+ ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw);
if (path->ah)
ipoib_put_ah(path->ah);
@@ -458,19 +444,15 @@ static void path_rec_completion(int status,
}
kref_get(&path->ah->ref);
neigh->ah = path->ah;
- memcpy(&neigh->dgid.raw, &path->pathrec.dgid.raw,
- sizeof(union ib_gid));
- if (ipoib_cm_enabled(dev, neigh->neighbour)) {
+ if (ipoib_cm_enabled(dev, neigh->daddr)) {
if (!ipoib_cm_get(neigh))
ipoib_cm_set(neigh, ipoib_cm_create_tx(dev,
path,
neigh));
if (!ipoib_cm_get(neigh)) {
list_del(&neigh->list);
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- ipoib_neigh_free(dev, neigh);
+ ipoib_neigh_free(neigh);
continue;
}
}
@@ -555,15 +537,15 @@ static int path_rec_start(struct net_device *dev,
return 0;
}
-/* called with rcu_read_lock */
-static void neigh_add_path(struct sk_buff *skb, struct neighbour *n, struct net_device *dev)
+static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
+ struct net_device *dev)
{
struct ipoib_dev_priv *priv = netdev_priv(dev);
struct ipoib_path *path;
struct ipoib_neigh *neigh;
unsigned long flags;
- neigh = ipoib_neigh_alloc(n, skb->dev);
+ neigh = ipoib_neigh_alloc(daddr, dev);
if (!neigh) {
++dev->stats.tx_dropped;
dev_kfree_skb_any(skb);
@@ -572,9 +554,9 @@ static void neigh_add_path(struct sk_buff *skb, struct neighbour *n, struct net_
spin_lock_irqsave(&priv->lock, flags);
- path = __path_find(dev, n->ha + 4);
+ path = __path_find(dev, daddr + 4);
if (!path) {
- path = path_rec_create(dev, n->ha + 4);
+ path = path_rec_create(dev, daddr + 4);
if (!path)
goto err_path;
@@ -586,17 +568,13 @@ static void neigh_add_path(struct sk_buff *skb, struct neighbour *n, struct net_
if (path->ah) {
kref_get(&path->ah->ref);
neigh->ah = path->ah;
- memcpy(&neigh->dgid.raw, &path->pathrec.dgid.raw,
- sizeof(union ib_gid));
- if (ipoib_cm_enabled(dev, neigh->neighbour)) {
+ if (ipoib_cm_enabled(dev, neigh->daddr)) {
if (!ipoib_cm_get(neigh))
ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, path, neigh));
if (!ipoib_cm_get(neigh)) {
list_del(&neigh->list);
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- ipoib_neigh_free(dev, neigh);
+ ipoib_neigh_free(neigh);
goto err_drop;
}
if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE)
@@ -608,7 +586,8 @@ static void neigh_add_path(struct sk_buff *skb, struct neighbour *n, struct net_
}
} else {
spin_unlock_irqrestore(&priv->lock, flags);
- ipoib_send(dev, skb, path->ah, IPOIB_QPN(n->ha));
+ ipoib_send(dev, skb, path->ah, IPOIB_QPN(daddr));
+ ipoib_neigh_put(neigh);
return;
}
} else {
@@ -621,35 +600,20 @@ static void neigh_add_path(struct sk_buff *skb, struct neighbour *n, struct net_
}
spin_unlock_irqrestore(&priv->lock, flags);
+ ipoib_neigh_put(neigh);
return;
err_list:
list_del(&neigh->list);
err_path:
- ipoib_neigh_free(dev, neigh);
+ ipoib_neigh_free(neigh);
err_drop:
++dev->stats.tx_dropped;
dev_kfree_skb_any(skb);
spin_unlock_irqrestore(&priv->lock, flags);
-}
-
-/* called with rcu_read_lock */
-static void ipoib_path_lookup(struct sk_buff *skb, struct neighbour *n, struct net_device *dev)
-{
- struct ipoib_dev_priv *priv = netdev_priv(skb->dev);
-
- /* Look up path record for unicasts */
- if (n->ha[4] != 0xff) {
- neigh_add_path(skb, n, dev);
- return;
- }
-
- /* Add in the P_Key for multicasts */
- n->ha[8] = (priv->pkey >> 8) & 0xff;
- n->ha[9] = priv->pkey & 0xff;
- ipoib_mcast_send(dev, n->ha + 4, skb);
+ ipoib_neigh_put(neigh);
}
static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev,
@@ -710,96 +674,80 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct ipoib_dev_priv *priv = netdev_priv(dev);
struct ipoib_neigh *neigh;
- struct neighbour *n = NULL;
+ struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
+ struct ipoib_header *header;
unsigned long flags;
- rcu_read_lock();
- if (likely(skb_dst(skb))) {
- n = dst_neigh_lookup_skb(skb_dst(skb), skb);
- if (!n) {
+ header = (struct ipoib_header *) skb->data;
+
+ if (unlikely(cb->hwaddr[4] == 0xff)) {
+ /* multicast, arrange "if" according to probability */
+ if ((header->proto != htons(ETH_P_IP)) &&
+ (header->proto != htons(ETH_P_IPV6)) &&
+ (header->proto != htons(ETH_P_ARP)) &&
+ (header->proto != htons(ETH_P_RARP))) {
+ /* ethertype not supported by IPoIB */
++dev->stats.tx_dropped;
dev_kfree_skb_any(skb);
- goto unlock;
+ return NETDEV_TX_OK;
}
+ /* Add in the P_Key for multicast*/
+ cb->hwaddr[8] = (priv->pkey >> 8) & 0xff;
+ cb->hwaddr[9] = priv->pkey & 0xff;
+
+ neigh = ipoib_neigh_get(dev, cb->hwaddr);
+ if (likely(neigh))
+ goto send_using_neigh;
+ ipoib_mcast_send(dev, cb->hwaddr, skb);
+ return NETDEV_TX_OK;
}
- if (likely(n)) {
- if (unlikely(!*to_ipoib_neigh(n))) {
- ipoib_path_lookup(skb, n, dev);
- goto unlock;
- }
- neigh = *to_ipoib_neigh(n);
-
- if (unlikely((memcmp(&neigh->dgid.raw,
- n->ha + 4,
- sizeof(union ib_gid))) ||
- (neigh->dev != dev))) {
- spin_lock_irqsave(&priv->lock, flags);
- /*
- * It's safe to call ipoib_put_ah() inside
- * priv->lock here, because we know that
- * path->ah will always hold one more reference,
- * so ipoib_put_ah() will never do more than
- * decrement the ref count.
- */
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- list_del(&neigh->list);
- ipoib_neigh_free(dev, neigh);
- spin_unlock_irqrestore(&priv->lock, flags);
- ipoib_path_lookup(skb, n, dev);
- goto unlock;
+ /* unicast, arrange "switch" according to probability */
+ switch (header->proto) {
+ case htons(ETH_P_IP):
+ case htons(ETH_P_IPV6):
+ neigh = ipoib_neigh_get(dev, cb->hwaddr);
+ if (unlikely(!neigh)) {
+ neigh_add_path(skb, cb->hwaddr, dev);
+ return NETDEV_TX_OK;
}
+ break;
+ case htons(ETH_P_ARP):
+ case htons(ETH_P_RARP):
+ /* for unicast ARP and RARP should always perform path find */
+ unicast_arp_send(skb, dev, cb);
+ return NETDEV_TX_OK;
+ default:
+ /* ethertype not supported by IPoIB */
+ ++dev->stats.tx_dropped;
+ dev_kfree_skb_any(skb);
+ return NETDEV_TX_OK;
+ }
- if (ipoib_cm_get(neigh)) {
- if (ipoib_cm_up(neigh)) {
- ipoib_cm_send(dev, skb, ipoib_cm_get(neigh));
- goto unlock;
- }
- } else if (neigh->ah) {
- ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(n->ha));
- goto unlock;
+send_using_neigh:
+ /* note we now hold a ref to neigh */
+ if (ipoib_cm_get(neigh)) {
+ if (ipoib_cm_up(neigh)) {
+ ipoib_cm_send(dev, skb, ipoib_cm_get(neigh));
+ goto unref;
}
+ } else if (neigh->ah) {
+ ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(cb->hwaddr));
+ goto unref;
+ }
- if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
- spin_lock_irqsave(&priv->lock, flags);
- __skb_queue_tail(&neigh->queue, skb);
- spin_unlock_irqrestore(&priv->lock, flags);
- } else {
- ++dev->stats.tx_dropped;
- dev_kfree_skb_any(skb);
- }
+ if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
+ spin_lock_irqsave(&priv->lock, flags);
+ __skb_queue_tail(&neigh->queue, skb);
+ spin_unlock_irqrestore(&priv->lock, flags);
} else {
- struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
-
- if (cb->hwaddr[4] == 0xff) {
- /* Add in the P_Key for multicast*/
- cb->hwaddr[8] = (priv->pkey >> 8) & 0xff;
- cb->hwaddr[9] = priv->pkey & 0xff;
+ ++dev->stats.tx_dropped;
+ dev_kfree_skb_any(skb);
+ }
- ipoib_mcast_send(dev, cb->hwaddr + 4, skb);
- } else {
- /* unicast GID -- should be ARP or RARP reply */
-
- if ((be16_to_cpup((__be16 *) skb->data) != ETH_P_ARP) &&
- (be16_to_cpup((__be16 *) skb->data) != ETH_P_RARP)) {
- ipoib_warn(priv, "Unicast, no %s: type %04x, QPN %06x %pI6\n",
- skb_dst(skb) ? "neigh" : "dst",
- be16_to_cpup((__be16 *) skb->data),
- IPOIB_QPN(cb->hwaddr),
- cb->hwaddr + 4);
- dev_kfree_skb_any(skb);
- ++dev->stats.tx_dropped;
- goto unlock;
- }
+unref:
+ ipoib_neigh_put(neigh);
- unicast_arp_send(skb, dev, cb);
- }
- }
-unlock:
- if (n)
- neigh_release(n);
- rcu_read_unlock();
return NETDEV_TX_OK;
}
@@ -821,6 +769,7 @@ static int ipoib_hard_header(struct sk_buff *skb,
const void *daddr, const void *saddr, unsigned len)
{
struct ipoib_header *header;
+ struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
header = (struct ipoib_header *) skb_push(skb, sizeof *header);
@@ -828,14 +777,11 @@ static int ipoib_hard_header(struct sk_buff *skb,
header->reserved = 0;
/*
- * If we don't have a dst_entry structure, stuff the
+ * we don't rely on dst_entry structure, always stuff the
* destination address into skb->cb so we can figure out where
* to send the packet later.
*/
- if (!skb_dst(skb)) {
- struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
- memcpy(cb->hwaddr, daddr, INFINIBAND_ALEN);
- }
+ memcpy(cb->hwaddr, daddr, INFINIBAND_ALEN);
return 0;
}
@@ -852,86 +798,431 @@ static void ipoib_set_mcast_list(struct net_device *dev)
queue_work(ipoib_workqueue, &priv->restart_task);
}
-static void ipoib_neigh_cleanup(struct neighbour *n)
+static u32 ipoib_addr_hash(struct ipoib_neigh_hash *htbl, u8 *daddr)
{
- struct ipoib_neigh *neigh;
- struct ipoib_dev_priv *priv = netdev_priv(n->dev);
+ /*
+ * Use only the address parts that contributes to spreading
+ * The subnet prefix is not used as one can not connect to
+ * same remote port (GUID) using the same remote QPN via two
+ * different subnets.
+ */
+ /* qpn octets[1:4) & port GUID octets[12:20) */
+ return jhash(daddr+12, 8, 0xFFFFFF & *(u32 *) daddr) & htbl->mask;
+}
+
+struct ipoib_neigh *ipoib_neigh_get(struct net_device *dev, u8 *daddr)
+{
+ struct ipoib_dev_priv *priv = netdev_priv(dev);
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ struct ipoib_neigh *neigh = NULL;
+ u32 hash_val;
+
+ rcu_read_lock_bh();
+
+ htbl = rcu_dereference_bh(ntbl->htbl);
+
+ if (!htbl)
+ goto out_unlock;
+
+ hash_val = ipoib_addr_hash(htbl, daddr);
+ for (neigh = rcu_dereference_bh(htbl->buckets[hash_val]);
+ neigh != NULL;
+ neigh = rcu_dereference_bh(neigh->hnext)) {
+ if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) {
+ /* found, take one ref on behalf of the caller */
+ if (!atomic_inc_not_zero(&neigh->refcnt)) {
+ /* deleted */
+ neigh = NULL;
+ goto out_unlock;
+ }
+ neigh->alive = jiffies;
+ goto out_unlock;
+ }
+ }
+out_unlock:
+ rcu_read_unlock_bh();
+ return neigh;
+}
+
+static void __ipoib_reap_neigh(struct ipoib_dev_priv *priv)
+{
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ unsigned long neigh_obsolete;
+ unsigned long dt;
unsigned long flags;
- struct ipoib_ah *ah = NULL;
+ int i;
- neigh = *to_ipoib_neigh(n);
- if (neigh)
- priv = netdev_priv(neigh->dev);
- else
+ if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
return;
- ipoib_dbg(priv,
- "neigh_cleanup for %06x %pI6\n",
- IPOIB_QPN(n->ha),
- n->ha + 4);
- spin_lock_irqsave(&priv->lock, flags);
+ write_lock_bh(&ntbl->rwlock);
+
+ htbl = rcu_dereference_protected(ntbl->htbl,
+ lockdep_is_held(&ntbl->rwlock));
+
+ if (!htbl)
+ goto out_unlock;
+
+ /* neigh is obsolete if it was idle for two GC periods */
+ dt = msecs_to_jiffies(2 * 1000 * IPOIB_NEIGH_GC_SEC);
+ neigh_obsolete = jiffies - dt;
+ /* handle possible race condition */
+ if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
+ goto out_unlock;
+
+ for (i = 0; i < htbl->size; i++) {
+ struct ipoib_neigh *neigh;
+ struct ipoib_neigh __rcu **np = &htbl->buckets[i];
+
+ while ((neigh = rcu_dereference_protected(*np,
+ lockdep_is_held(&ntbl->lock))) != NULL) {
+ /* was the neigh idle for two GC periods */
+ if (time_after(neigh_obsolete, neigh->alive)) {
+ rcu_assign_pointer(*np,
+ rcu_dereference_protected(neigh->hnext,
+ lockdep_is_held(&ntbl->rwlock)));
+ /* remove from path/mc list */
+ spin_lock_irqsave(&priv->lock, flags);
+ list_del(&neigh->list);
+ spin_unlock_irqrestore(&priv->lock, flags);
+ call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
+ } else {
+ np = &neigh->hnext;
+ }
- if (neigh->ah)
- ah = neigh->ah;
- list_del(&neigh->list);
- ipoib_neigh_free(n->dev, neigh);
+ }
+ }
+out_unlock:
+ write_unlock_bh(&ntbl->rwlock);
+}
- spin_unlock_irqrestore(&priv->lock, flags);
+static void ipoib_reap_neigh(struct work_struct *work)
+{
+ struct ipoib_dev_priv *priv =
+ container_of(work, struct ipoib_dev_priv, neigh_reap_task.work);
+ unsigned long dt = msecs_to_jiffies(1000 * IPOIB_NEIGH_GC_SEC);
+
+ __ipoib_reap_neigh(priv);
- if (ah)
- ipoib_put_ah(ah);
+ if (!test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
+ queue_delayed_work(ipoib_workqueue, &priv->neigh_reap_task,
+ round_jiffies_relative(dt));
}
-struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neighbour,
+
+static struct ipoib_neigh *ipoib_neigh_ctor(u8 *daddr,
struct net_device *dev)
{
struct ipoib_neigh *neigh;
- neigh = kmalloc(sizeof *neigh, GFP_ATOMIC);
+ neigh = kzalloc(sizeof *neigh, GFP_ATOMIC);
if (!neigh)
return NULL;
- neigh->neighbour = neighbour;
neigh->dev = dev;
- memset(&neigh->dgid.raw, 0, sizeof (union ib_gid));
- *to_ipoib_neigh(neighbour) = neigh;
+ memcpy(&neigh->daddr, daddr, sizeof(neigh->daddr));
skb_queue_head_init(&neigh->queue);
+ INIT_LIST_HEAD(&neigh->list);
ipoib_cm_set(neigh, NULL);
+ /* one ref on behalf of the caller */
+ atomic_set(&neigh->refcnt, 1);
+
+ return neigh;
+}
+
+struct ipoib_neigh *ipoib_neigh_alloc(u8 *daddr,
+ struct net_device *dev)
+{
+ struct ipoib_dev_priv *priv = netdev_priv(dev);
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ struct ipoib_neigh *neigh;
+ u32 hash_val;
+
+ write_lock_bh(&ntbl->rwlock);
+
+ htbl = rcu_dereference_protected(ntbl->htbl,
+ lockdep_is_held(&ntbl->rwlock));
+ if (!htbl) {
+ neigh = NULL;
+ goto out_unlock;
+ }
+
+ /* need to add a new neigh, but maybe some other thered succeded ?
+ * recalc hash, maybe hash resize took place so we do a search
+ */
+ hash_val = ipoib_addr_hash(htbl, daddr);
+ for (neigh = rcu_dereference_protected(htbl->buckets[hash_val],
+ lockdep_is_held(&ntbl->rwlock));
+ neigh != NULL;
+ neigh = rcu_dereference_protected(neigh->hnext,
+ lockdep_is_held(&ntbl->lock))) {
+ if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) {
+ /* found, take one ref on behalf of the caller */
+ if (!atomic_inc_not_zero(&neigh->refcnt)) {
+ /* deleted */
+ neigh = NULL;
+ break;
+ }
+ neigh->alive = jiffies;
+ goto out_unlock;
+ }
+ }
+
+ neigh = ipoib_neigh_ctor(daddr, dev);
+ if (!neigh)
+ goto out_unlock;
+
+ /* one ref on behalf of the hash table */
+ atomic_inc(&neigh->refcnt);
+ neigh->alive = jiffies;
+ /* put in hash */
+ rcu_assign_pointer(neigh->hnext,
+ rcu_dereference_protected(htbl->buckets[hash_val],
+ lockdep_is_held(&ntbl->rwlock)));
+ rcu_assign_pointer(htbl->buckets[hash_val], neigh);
+ atomic_inc(&ntbl->entries);
+
+out_unlock:
+ write_unlock_bh(&ntbl->rwlock);
return neigh;
}
-void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh)
+void ipoib_neigh_dtor(struct ipoib_neigh *neigh)
{
+ /* neigh reference count was dropprd to zero */
+ struct net_device *dev = neigh->dev;
+ struct ipoib_dev_priv *priv = netdev_priv(dev);
struct sk_buff *skb;
- *to_ipoib_neigh(neigh->neighbour) = NULL;
+ if (neigh->ah)
+ ipoib_put_ah(neigh->ah);
while ((skb = __skb_dequeue(&neigh->queue))) {
++dev->stats.tx_dropped;
dev_kfree_skb_any(skb);
}
if (ipoib_cm_get(neigh))
ipoib_cm_destroy_tx(ipoib_cm_get(neigh));
+ ipoib_dbg(netdev_priv(dev),
+ "neigh free for %06x %pI6\n",
+ IPOIB_QPN(neigh->daddr),
+ neigh->daddr + 4);
kfree(neigh);
+ if (atomic_dec_and_test(&priv->ntbl.entries)) {
+ if (test_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags))
+ complete(&priv->ntbl.flushed);
+ }
+}
+
+static void ipoib_neigh_reclaim(struct rcu_head *rp)
+{
+ /* Called as a result of removal from hash table */
+ struct ipoib_neigh *neigh = container_of(rp, struct ipoib_neigh, rcu);
+ /* note TX context may hold another ref */
+ ipoib_neigh_put(neigh);
}
-static int ipoib_neigh_setup_dev(struct net_device *dev, struct neigh_parms *parms)
+void ipoib_neigh_free(struct ipoib_neigh *neigh)
{
- parms->neigh_cleanup = ipoib_neigh_cleanup;
+ struct net_device *dev = neigh->dev;
+ struct ipoib_dev_priv *priv = netdev_priv(dev);
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ struct ipoib_neigh __rcu **np;
+ struct ipoib_neigh *n;
+ u32 hash_val;
+
+ write_lock_bh(&ntbl->rwlock);
+
+ htbl = rcu_dereference_protected(ntbl->htbl,
+ lockdep_is_held(&ntbl->rwlock));
+ if (!htbl)
+ goto out_unlock;
+
+ hash_val = ipoib_addr_hash(htbl, neigh->daddr);
+ np = &htbl->buckets[hash_val];
+ for (n = rcu_dereference_protected(*np,
+ lockdep_is_held(&ntbl->rwlock));
+ n != NULL;
+ n = rcu_dereference_protected(neigh->hnext,
+ lockdep_is_held(&ntbl->lock))) {
+ if (n == neigh) {
+ /* found */
+ rcu_assign_pointer(*np,
+ rcu_dereference_protected(neigh->hnext,
+ lockdep_is_held(&ntbl->rwlock)));
+ call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
+ goto out_unlock;
+ } else {
+ np = &n->hnext;
+ }
+ }
+out_unlock:
+ write_unlock_bh(&ntbl->rwlock);
+
+}
+
+static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv)
+{
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ struct ipoib_neigh **buckets;
+ unsigned long dt = msecs_to_jiffies(1000 * IPOIB_NEIGH_GC_SEC);
+ u32 size;
+
+ clear_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);
+ ntbl->htbl = NULL;
+ rwlock_init(&ntbl->rwlock);
+ htbl = kzalloc(sizeof(*htbl), GFP_KERNEL);
+ if (!htbl)
+ return -ENOMEM;
+ set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
+ size = 1 << IPOIB_NEIGH_LOG_INIT_SIZE;
+ buckets = kzalloc(size * sizeof(*buckets), GFP_KERNEL);
+ if (!buckets) {
+ kfree(htbl);
+ return -ENOMEM;
+ }
+ htbl->size = size;
+ htbl->mask = (size - 1);
+ htbl->buckets = buckets;
+ ntbl->htbl = htbl;
+ atomic_set(&ntbl->entries, 0);
+
+ /* start garbage collection */
+ clear_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
+ queue_delayed_work(ipoib_workqueue, &priv->neigh_reap_task,
+ round_jiffies_relative(dt));
return 0;
}
+static void neigh_hash_free_rcu(struct rcu_head *head)
+{
+ struct ipoib_neigh_hash *htbl = container_of(head,
+ struct ipoib_neigh_hash,
+ rcu);
+ struct ipoib_neigh __rcu **buckets = htbl->buckets;
+
+ kfree(buckets);
+ kfree(htbl);
+}
+
+void ipoib_del_neighs_by_gid(struct net_device *dev, u8 *gid)
+{
+ struct ipoib_dev_priv *priv = netdev_priv(dev);
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ unsigned long flags;
+ int i;
+
+ /* remove all neigh connected to a given path or mcast */
+ write_lock_bh(&ntbl->rwlock);
+
+ htbl = rcu_dereference_protected(ntbl->htbl,
+ lockdep_is_held(&ntbl->rwlock));
+
+ if (!htbl)
+ goto out_unlock;
+
+ for (i = 0; i < htbl->size; i++) {
+ struct ipoib_neigh *neigh;
+ struct ipoib_neigh __rcu **np = &htbl->buckets[i];
+
+ while ((neigh = rcu_dereference_protected(*np,
+ lockdep_is_held(&ntbl->lock))) != NULL) {
+ /* delete neighs belong to this parent */
+ if (!memcmp(gid, neigh->daddr + 4, sizeof (union ib_gid))) {
+ rcu_assign_pointer(*np,
+ rcu_dereference_protected(neigh->hnext,
+ lockdep_is_held(&ntbl->rwlock)));
+ /* remove from parent list */
+ spin_lock_irqsave(&priv->lock, flags);
+ list_del(&neigh->list);
+ spin_unlock_irqrestore(&priv->lock, flags);
+ call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
+ } else {
+ np = &neigh->hnext;
+ }
+
+ }
+ }
+out_unlock:
+ write_unlock_bh(&ntbl->rwlock);
+}
+
+static void ipoib_flush_neighs(struct ipoib_dev_priv *priv)
+{
+ struct ipoib_neigh_table *ntbl = &priv->ntbl;
+ struct ipoib_neigh_hash *htbl;
+ unsigned long flags;
+ int i;
+
+ write_lock_bh(&ntbl->rwlock);
+
+ htbl = rcu_dereference_protected(ntbl->htbl,
+ lockdep_is_held(&ntbl->rwlock));
+ if (!htbl)
+ goto out_unlock;
+
+ for (i = 0; i < htbl->size; i++) {
+ struct ipoib_neigh *neigh;
+ struct ipoib_neigh __rcu **np = &htbl->buckets[i];
+
+ while ((neigh = rcu_dereference_protected(*np,
+ lockdep_is_held(&ntbl->lock))) != NULL) {
+ rcu_assign_pointer(*np,
+ rcu_dereference_protected(neigh->hnext,
+ lockdep_is_held(&ntbl->rwlock)));
+ /* remove from path/mc list */
+ spin_lock_irqsave(&priv->lock, flags);
+ list_del(&neigh->list);
+ spin_unlock_irqrestore(&priv->lock, flags);
+ call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
+ }
+ }
+ rcu_assign_pointer(ntbl->htbl, NULL);
+ call_rcu(&htbl->rcu, neigh_hash_free_rcu);
+out_unlock:
+ write_unlock_bh(&ntbl->rwlock);
+}
+
+static void ipoib_neigh_hash_uninit(struct net_device *dev)
+{
+ struct ipoib_dev_priv *priv = netdev_priv(dev);
+ int stopped;
+
+ ipoib_dbg(priv, "ipoib_neigh_hash_uninit\n");
+ init_completion(&priv->ntbl.flushed);
+ set_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);
+
+ /* Stop GC if called at init fail need to cancel work */
+ stopped = test_and_set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
+ if (!stopped)
+ cancel_delayed_work(&priv->neigh_reap_task);
+
+ if (atomic_read(&priv->ntbl.entries)) {
+ ipoib_flush_neighs(priv);
+ wait_for_completion(&priv->ntbl.flushed);
+ }
+}
+
+
int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port)
{
struct ipoib_dev_priv *priv = netdev_priv(dev);
+ if (ipoib_neigh_hash_init(priv) < 0)
+ goto out;
/* Allocate RX/TX "rings" to hold queued skbs */
priv->rx_ring = kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring,
GFP_KERNEL);
if (!priv->rx_ring) {
printk(KERN_WARNING "%s: failed to allocate RX ring (%d entries)\n",
ca->name, ipoib_recvq_size);
- goto out;
+ goto out_neigh_hash_cleanup;
}
priv->tx_ring = vzalloc(ipoib_sendq_size * sizeof *priv->tx_ring);
@@ -954,6 +1245,8 @@ out_tx_ring_cleanup:
out_rx_ring_cleanup:
kfree(priv->rx_ring);
+out_neigh_hash_cleanup:
+ ipoib_neigh_hash_uninit(dev);
out:
return -ENOMEM;
}
@@ -966,6 +1259,9 @@ void ipoib_dev_cleanup(struct net_device *dev)
/* Delete any child interfaces first */
list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) {
+ /* Stop GC on child */
+ set_bit(IPOIB_STOP_NEIGH_GC, &cpriv->flags);
+ cancel_delayed_work(&cpriv->neigh_reap_task);
unregister_netdev(cpriv->dev);
ipoib_dev_cleanup(cpriv->dev);
free_netdev(cpriv->dev);
@@ -978,6 +1274,8 @@ void ipoib_dev_cleanup(struct net_device *dev)
priv->rx_ring = NULL;
priv->tx_ring = NULL;
+
+ ipoib_neigh_hash_uninit(dev);
}
static const struct header_ops ipoib_header_ops = {
@@ -992,7 +1290,6 @@ static const struct net_device_ops ipoib_netdev_ops = {
.ndo_start_xmit = ipoib_start_xmit,
.ndo_tx_timeout = ipoib_timeout,
.ndo_set_rx_mode = ipoib_set_mcast_list,
- .ndo_neigh_setup = ipoib_neigh_setup_dev,
};
static void ipoib_setup(struct net_device *dev)
@@ -1041,6 +1338,7 @@ static void ipoib_setup(struct net_device *dev)
INIT_WORK(&priv->flush_heavy, ipoib_ib_dev_flush_heavy);
INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task);
INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah);
+ INIT_DELAYED_WORK(&priv->neigh_reap_task, ipoib_reap_neigh);
}
struct ipoib_dev_priv *ipoib_intf_alloc(const char *name)
@@ -1281,6 +1579,9 @@ sysfs_failed:
register_failed:
ib_unregister_event_handler(&priv->event_handler);
+ /* Stop GC if started before flush */
+ set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
+ cancel_delayed_work(&priv->neigh_reap_task);
flush_workqueue(ipoib_workqueue);
event_failed:
@@ -1347,6 +1648,9 @@ static void ipoib_remove_one(struct ib_device *device)
dev_change_flags(priv->dev, priv->dev->flags & ~IFF_UP);
rtnl_unlock();
+ /* Stop GC */
+ set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
+ cancel_delayed_work(&priv->neigh_reap_task);
flush_workqueue(ipoib_workqueue);
unregister_netdev(priv->dev);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index 7cecb16..13f4aa7 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -69,28 +69,13 @@ struct ipoib_mcast_iter {
static void ipoib_mcast_free(struct ipoib_mcast *mcast)
{
struct net_device *dev = mcast->dev;
- struct ipoib_dev_priv *priv = netdev_priv(dev);
- struct ipoib_neigh *neigh, *tmp;
int tx_dropped = 0;
ipoib_dbg_mcast(netdev_priv(dev), "deleting multicast group %pI6\n",
mcast->mcmember.mgid.raw);
- spin_lock_irq(&priv->lock);
-
- list_for_each_entry_safe(neigh, tmp, &mcast->neigh_list, list) {
- /*
- * It's safe to call ipoib_put_ah() inside priv->lock
- * here, because we know that mcast->ah will always
- * hold one more reference, so ipoib_put_ah() will
- * never do more than decrement the ref count.
- */
- if (neigh->ah)
- ipoib_put_ah(neigh->ah);
- ipoib_neigh_free(dev, neigh);
- }
-
- spin_unlock_irq(&priv->lock);
+ /* remove all neigh connected to this mcast */
+ ipoib_del_neighs_by_gid(dev, mcast->mcmember.mgid.raw);
if (mcast->ah)
ipoib_put_ah(mcast->ah);
@@ -655,17 +640,12 @@ static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast)
return 0;
}
-void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb)
+void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb)
{
struct ipoib_dev_priv *priv = netdev_priv(dev);
- struct dst_entry *dst = skb_dst(skb);
struct ipoib_mcast *mcast;
- struct neighbour *n;
unsigned long flags;
-
- n = NULL;
- if (dst)
- n = dst_neigh_lookup_skb(dst, skb);
+ void *mgid = daddr + 4;
spin_lock_irqsave(&priv->lock, flags);
@@ -721,28 +701,29 @@ void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb)
out:
if (mcast && mcast->ah) {
- if (n) {
- if (!*to_ipoib_neigh(n)) {
- struct ipoib_neigh *neigh;
-
- neigh = ipoib_neigh_alloc(n, skb->dev);
- if (neigh) {
- kref_get(&mcast->ah->ref);
- neigh->ah = mcast->ah;
- list_add_tail(&neigh->list,
- &mcast->neigh_list);
- }
+ struct ipoib_neigh *neigh;
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+ neigh = ipoib_neigh_get(dev, daddr);
+ spin_lock_irqsave(&priv->lock, flags);
+ if (!neigh) {
+ spin_unlock_irqrestore(&priv->lock, flags);
+ neigh = ipoib_neigh_alloc(daddr, dev);
+ spin_lock_irqsave(&priv->lock, flags);
+ if (neigh) {
+ kref_get(&mcast->ah->ref);
+ neigh->ah = mcast->ah;
+ list_add_tail(&neigh->list, &mcast->neigh_list);
}
- neigh_release(n);
}
spin_unlock_irqrestore(&priv->lock, flags);
ipoib_send(dev, skb, mcast->ah, IB_MULTICAST_QPN);
+ if (neigh)
+ ipoib_neigh_put(neigh);
return;
}
unlock:
- if (n)
- neigh_release(n);
spin_unlock_irqrestore(&priv->lock, flags);
}
--
1.7.1
^ permalink raw reply related
* [PATCH RESEND net/for-next V1 0/1] changes IPoIB neighbour handling
From: Or Gerlitz @ 2012-07-19 16:15 UTC (permalink / raw)
To: roland, davem; +Cc: linux-rdma, erezsh, netdev, Or Gerlitz, Shlomo Pongratz
Adding netdev, as of the high relevancy, see V0 @
http://marc.info/?l=linux-rdma&m=134191474831867&w=2
changes from V0:
- following feedback from Mike and Dave, changed the ipoib_neigh hash table
to allow for lock-free read side, the model follows the RCU based implementation
in net/core/neighbour.c
- since RCU hash table uses unidirectional collision list, now ipoib_neigh_free
needs to do a linked search in order to find the deleted neighbour predecessor
in order to link it to the neighbour successor.
- different implementation of hash lookup in ipoib_neigh_get (read-side)
vs ipoib_neigh_alloc and ipoib_neigh_free (write-side)
- path_free and ipoib_mcast_free now make use of the ipoib_del_neighs_by_gid helper
function in order to delete neighbours related to that path or mcast. This new helper
scans the hash table and deletes neighbours with the given GID. It had to be done
this way of as of the unidrectional nature of the linking which by itself
arises from the lock free requirement made here...
- a completion mechanism was added to prevent freeing the IPoIB netdevice priv
data structure before the RCU based code freed all the neighbours.
Again, the patch was made over net-next as of few IPoIB changes that
took place there and the parallel submission of the eIPoIB driver.
Or.
Shlomo Pongratz (1):
IB/ipoib: break linkage to neighbouring system
drivers/infiniband/ulp/ipoib/ipoib.h | 59 ++-
drivers/infiniband/ulp/ipoib/ipoib_cm.c | 16 +-
drivers/infiniband/ulp/ipoib/ipoib_main.c | 638 +++++++++++++++++------
drivers/infiniband/ulp/ipoib/ipoib_multicast.c | 57 +--
4 files changed, 535 insertions(+), 235 deletions(-)
Cc: Shlomo Pongratz <shlomop@mellanox.com>
^ permalink raw reply
* Re: getsockopt/setsockopt with SO_RCVBUF and SO_SNDBUF "non-standard" behaviour
From: Eugen Dedu @ 2012-07-19 16:14 UTC (permalink / raw)
To: Rick Jones; +Cc: Eric Dumazet, linux-kernel@vger.kernel.org, netdev
In-Reply-To: <5006F32E.8060405@hp.com>
On 18/07/12 19:32, Rick Jones wrote:
> On 07/18/2012 09:11 AM, Eric Dumazet wrote:
>>
>> That the way it's done on linux since day 0
>>
>> You can probably find a lot of pages on the web explaining the
>> rationale.
>>
>> If your application handles UDP frames, what SO_RCVBUF should count ?
>>
>> If its the amount of payload bytes, you could have a pathological
>> situation where an attacker sends 1-byte UDP frames fast enough and
>> could consume a lot of kernel memory.
>>
>> Each frame consumes a fair amount of kernel memory (between 512 bytes
>> and 8 Kbytes depending on the driver).
>>
>> So linux says : If user expect to receive XXXX bytes, set a limit of
>> _kernel_ memory used to store these bytes, and use an estimation of 100%
>> of overhead. That is : allow 2*XXXX bytes to be allocated for socket
>> receive buffers.
>
> Expanding on/rewording that, in a setsockopt() call SO_RCVBUF specifies
> the data bytes and gets doubled to become the kernel/overhead byte
> limit. Unless the doubling would be greater than net.core.rmem_max, in
> which case the limit becomes net.core.rmem_max.
>
> But on getsockopt() SO_RCVBUF is always the kernel/overhead byte limit.
>
> In one call it is fish. In the other it is fowl.
>
> Other stacks appear to keep their kernel/overhead limit quiet, keeping
> SO_RCVBUF an expression of a data limit in both setsockopt() and
> getsockopt(). With those stacks, there is I suppose the possible source
> of confusion when/if someone tests the queuing to a socket, sends "high
> overhead" packets and doesn't get to SO_RCVBUF worth of data though I
> don't recall encountering that in my "pre-linux" time.
Thank you to both for the answers. As I understand, it it is impossible
(or not practical) to fulfill sometimes user requirements on buff size,
since if only 1-byte udp packets arrive and are not consumed by
application, the memory needed by linux is say 1000 greater, which of
course is not available. Other OSes have the same problem (see above
"doesn't get to SO_RCVBUF worth of data"), except that they return the
same value in getsockopt as setsockopt. However, note that with linux
the confusion is still possible, even if it appears more rarely.
> The sometimes fish, sometimes fowl version (along with the auto tuning
> when one doesn't make setsockopt() calls) gave me fits in netperf for
> years until I finally relented and split the socket buffer size
> variables into three - what netperf's user requested via the command
> line, what it was right after the socket was created, and what it was at
> the end of the data phase of the test.
--
Eugen
^ permalink raw reply
* Re: [PATCH] Crash in tun
From: Mikulas Patocka @ 2012-07-19 16:13 UTC (permalink / raw)
To: Eric Dumazet; +Cc: Maxim Krasnyansky, vtun, netdev, davem
In-Reply-To: <1342678175.2626.3849.camel@edumazet-glaptop>
On Thu, 19 Jul 2012, Eric Dumazet wrote:
> Hi Mikulas
>
> A fix for this problem is : http://patchwork.ozlabs.org/patch/170440/
If you call tun_free_netdev beacuse of a jump to an error label
err_free_sk, your patch still calls it with NULL file, causing a memory
corruption and a possible crash.
Your patch doesn't fix sockets_in_use underflow.
Maybe we can commit this patch --- it introduces a new flag
SOCK_EXTERNALLY_ALLOCATED to work around both problems. (it looks quite
nicer than my previous patch with file = (void *)1).
Mikulas
---
tun: fix a crash bug and a memory leak
This patch fixes a crash
tun_chr_close -> netdev_run_todo -> tun_free_netdev -> sk_release_kernel ->
sock_release -> iput(SOCK_INODE(sock))
introduced by commit 1ab5ecb90cb6a3df1476e052f76a6e8f6511cb3d
The problem is that this socket is embedded in struct tun_struct, it has
no inode, iput is called on invalid inode, which modifies invalid memory
and optionally causes a crash.
sock_release also decrements sockets_in_use, this causes a bug that
"sockets: used" field in /proc/*/net/sockstat keeps on decreasing when
creating and closing tun devices.
This patch introduces a flag SOCK_EXTERNALLY_ALLOCATED that instructs
sock_release to not free the inode and not decrement sockets_in_use,
fixing both memory corruption and sockets_in_use underflow.
It should be backported to 3.3 an 3.4 stabke.
Signed-off-by: Mikulas Patocka <mikulas@artax.karlin.mff.cuni.cz>
Cc: stable@kernel.org
---
drivers/net/tun.c | 3 +++
include/linux/net.h | 1 +
net/socket.c | 3 +++
3 files changed, 7 insertions(+)
Index: linux-3.4.5-fast/drivers/net/tun.c
===================================================================
--- linux-3.4.5-fast.orig/drivers/net/tun.c 2012-07-19 17:55:16.000000000 +0200
+++ linux-3.4.5-fast/drivers/net/tun.c 2012-07-19 17:58:30.000000000 +0200
@@ -358,6 +358,8 @@ static void tun_free_netdev(struct net_d
{
struct tun_struct *tun = netdev_priv(dev);
+ BUG_ON(!test_bit(SOCK_EXTERNALLY_ALLOCATED, &tun->socket.flags));
+
sk_release_kernel(tun->socket.sk);
}
@@ -1115,6 +1117,7 @@ static int tun_set_iff(struct net *net,
tun->flags = flags;
tun->txflt.count = 0;
tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
+ set_bit(SOCK_EXTERNALLY_ALLOCATED, &tun->socket.flags);
err = -ENOMEM;
sk = sk_alloc(&init_net, AF_UNSPEC, GFP_KERNEL, &tun_proto);
Index: linux-3.4.5-fast/include/linux/net.h
===================================================================
--- linux-3.4.5-fast.orig/include/linux/net.h 2012-07-19 17:54:31.000000000 +0200
+++ linux-3.4.5-fast/include/linux/net.h 2012-07-19 17:55:03.000000000 +0200
@@ -72,6 +72,7 @@ struct net;
#define SOCK_NOSPACE 2
#define SOCK_PASSCRED 3
#define SOCK_PASSSEC 4
+#define SOCK_EXTERNALLY_ALLOCATED 5
#ifndef ARCH_HAS_SOCKET_TYPES
/**
Index: linux-3.4.5-fast/net/socket.c
===================================================================
--- linux-3.4.5-fast.orig/net/socket.c 2012-07-19 17:56:55.000000000 +0200
+++ linux-3.4.5-fast/net/socket.c 2012-07-19 17:57:50.000000000 +0200
@@ -522,6 +522,9 @@ void sock_release(struct socket *sock)
if (rcu_dereference_protected(sock->wq, 1)->fasync_list)
printk(KERN_ERR "sock_release: fasync list not empty!\n");
+ if (test_bit(SOCK_EXTERNALLY_ALLOCATED, &sock->flags))
+ return;
+
percpu_sub(sockets_in_use, 1);
if (!sock->file) {
iput(SOCK_INODE(sock));
^ permalink raw reply
* Re: [net-next 9/9] ixgbe: Cleanup holes in flags after removing several of them
From: Alexander Duyck @ 2012-07-19 16:11 UTC (permalink / raw)
To: David Laight; +Cc: Jeff Kirsher, davem, netdev, gospo, sassmann
In-Reply-To: <AE90C24D6B3A694183C094C60CF0A2F6026B6F98@saturn3.aculab.com>
On 07/19/2012 01:33 AM, David Laight wrote:
>> This change is just meant to defragment the flags as there are several
> hole
>> that have been introduced since several features, or the flags for
> them,
>> have been removed.
> Doesn't this sort of change just make it difficult for people who are
> looking at hexdumps of memory but don't have exactly the right header
> file to hand?
These are private flags held inside of the driver and never exposed
externally to user space. If we have to go through a hexdump to try and
figure out the state of the driver I would certainly hope we have the
header file in hand. Knowing what bits we use is kind of pointless if
we don't know where the flags are being stored within the adapter
structure itself.
> It doesn't really gain anything much either.
I never did say it gains us much. It is mostly just housekeeping in
order to make it clear where the available bits are in the flags fields.
> I can (just) imagine reordering flags so that the commonly
> tested ones are in the low bits so that they can be tested
> with small immediate constants - saving an instruction.
> But that isn't what is being done here.
>
> David
On x86 it seems like gcc is converting all of the flag tests to "testb"
assembly ops and just using an offset within the flags field to access
bits 8 through 31. It doesn't seem like there would be much of an
advantage to reordering the flags unless we need to optimize for the
cases where we are testing multiple flags. Even in that case we would
probably just want to align things so that when we access multiple flags
they are in the same 8 bit field.
Thanks,
Alex
^ permalink raw reply
* Re: [PATCH net-next 4/7] sfc: Add support for IEEE-1588 PTP
From: Andrew Jackson @ 2012-07-19 16:05 UTC (permalink / raw)
To: Ben Hutchings; +Cc: Richard Cochran, David Miller, netdev, linux-net-drivers
In-Reply-To: <1342708653.2617.33.camel@bwh-desktop.uk.solarflarecom.com>
On 19/07/2012 15:37, Ben Hutchings wrote:
> On Thu, 2012-07-19 at 16:25 +0200, Richard Cochran wrote:
>> On Wed, Jul 18, 2012 at 07:21:33PM +0100, Ben Hutchings wrote:
>>> +/* Process times received from MC.
>>> + *
>>> + * Extract times from returned results, and establish the minimum value
>>> + * seen. The minimum value represents the "best" possible time and events
>>> + * too much greater than this are rejected - the machine is, perhaps, too
>>> + * busy. A number of readings are taken so that, hopefully, at least one good
>>> + * synchronisation will be seen in the results.
>>> + */
>>
>> This code looks like it is trying to find the offset between two
>> clocks. Is there some reason why you cannot use <linux/timecompare.h>
>> to accomplish this?
>>
>> Also, these comments about "hopefull" synchronization make me
>> nervous. I think it might be easier just to offer RAW timestamps and
>> forget about the SYS timestamps.
>>
>> I am trying to purge the whole SYS thing (only blackfin is left)
>> because there is a much better way to go about this, namely
>> synchronizing the system time to the PHC time via an internal PPS
>> signal.
>
> Andrew, would that work for us?
I don't think so for the reason that Stu has pointed out (failed
assumption).
The NIC's clock isn't directly accessible by the host from the PCIe bus
and is "behind" the MC. Even when we process PPS events, we need a
reliable way of determining the relationship between the two clocks
(system <> NIC). We're trying to get that as accurately as we can but we
know that some measurements will be incorrect/out of bounds because of
loading on the system.
In retrospect, I should have phrased the comment in more statistical
terms rather than using ambiguous phrases like "hopefully".
Andrew
^ permalink raw reply
* Re: [PATCH net-next V1 5/9] net/eipoib: Add ethtool file support
From: Or Gerlitz @ 2012-07-19 15:55 UTC (permalink / raw)
To: Ben Hutchings
Cc: davem, roland, netdev, ali, sean.hefty, shlomop, Erez Shitrit
In-Reply-To: <1342636621.2617.63.camel@bwh-desktop.uk.solarflarecom.com>
On 7/18/2012 9:37 PM, Ben Hutchings wrote:
> +static void parent_get_strings(struct net_device *parent_dev,
> + uint32_t stringset, uint8_t *data)
> +{
> + int index = 0, stats_off = 0, i;
> +
> + if (stringset != ETH_SS_STATS)
> + return;
> +
> + for (i = 0; i < PORT_STATS_LEN; i++)
> + strcpy(data + (index++) * ETH_GSTRING_LEN,
> + parent_strings[i + stats_off]);
> +
> + stats_off += PORT_STATS_LEN;
> This is a very longwinded way to write:
> memcpy(data, parent_strings, sizeof(parent_strings));
SURE, will fix
>
>> +static int parent_get_sset_count(struct net_device *parent_dev, int sset)
>> +{
>> + switch (sset) {
>> + case ETH_SS_STATS:
>> + return PARENT_STATS_LEN;
>>
> [...]
>
> I get the feeling you've removed some code with unifdef; the result
> looks really weird, with PORT_STATS_LEN and PARENT_STATS_LEN used
> inconsistently.
yep, this needs cleanup, will do for V2
Or.
^ permalink raw reply
* Re: [PATCH 09/15] ipv4: Cache output routes in fib_info nexthops.
From: David Miller @ 2012-07-19 15:52 UTC (permalink / raw)
To: netdev
In-Reply-To: <20120718.112404.1910372180742347127.davem@davemloft.net>
In a dream I found a bug in this patch and the next one.
When we fetch a cached route from the FIB info, we have to
check if it has been invalidated by a PMTU event or similar.
And if so, cmpxchg() it with NULL and release it, so we
can build and install a new cached route there.
I'll fix this up when I integrate everyone's feedback later
today.
^ permalink raw reply
* Re: [PATCH net-next 4/7] sfc: Add support for IEEE-1588 PTP
From: Ben Hutchings @ 2012-07-19 15:50 UTC (permalink / raw)
To: Stuart Hodgson
Cc: Richard Cochran, David Miller, netdev, linux-net-drivers,
Andrew Jackson
In-Reply-To: <500827EF.208@solarflare.com>
On Thu, 2012-07-19 at 16:29 +0100, Stuart Hodgson wrote:
> On 19/07/12 15:25, Richard Cochran wrote:
[...]
> > I am trying to purge the whole SYS thing (only blackfin is left)
> > because there is a much better way to go about this, namely
> > synchronizing the system time to the PHC time via an internal PPS
> > signal.
>
> This may be possible in future. But leads us to another problem
> where the PPS event that is generated by the PHC subsystem to the
> PPS subsystem is stamped with the current system_time. That may
> be fine for a PPS signal generated from an interrupt but not when
> the internal PPS event has implicit jitter from the handler/event_queue
> that we have in the driver.
[...]
We can certainly take a timestamp in the hard interrupt handler; in fact
that's what I originally expected we would do since we have a separate
MSI-X vector for PTP. But even hard interrupt handling can be subject
to substantial jitter.
Ben.
--
Ben Hutchings, Staff Engineer, Solarflare
Not speaking for my employer; that's the marketing department's job.
They asked us to note that Solarflare product names are trademarked.
^ permalink raw reply
* [PATCH] ipv4: Fix time difference calculation in rt_bind_exception().
From: David Miller @ 2012-07-19 15:50 UTC (permalink / raw)
To: netdev
Reported-by: Steffen Klassert <steffen.klassert@secunet.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
---
net/ipv4/route.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index f67e702..2c25581 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1907,7 +1907,7 @@ static void rt_bind_exception(struct rtable *rt, struct fib_nh *nh, __be32 daddr
if (fnhe->fnhe_daddr == daddr) {
if (fnhe->fnhe_pmtu) {
unsigned long expires = fnhe->fnhe_expires;
- unsigned long diff = jiffies - expires;
+ unsigned long diff = expires - jiffies;
if (time_before(jiffies, expires)) {
rt->rt_pmtu = fnhe->fnhe_pmtu;
--
1.7.10.4
^ permalink raw reply related
* Re: [PATCH net-next V1 7/9] net/eipoib: Add main driver functionality
From: Or Gerlitz @ 2012-07-19 15:46 UTC (permalink / raw)
To: Ben Hutchings
Cc: davem, roland, netdev, ali, sean.hefty, shlomop, Erez Shitrit
In-Reply-To: <1342705789.2617.15.camel@bwh-desktop.uk.solarflarecom.com>
On 7/19/2012 4:49 PM, Ben Hutchings wrote:
> On Wed, 2012-07-18 at 14:00 +0300, Or Gerlitz wrote:
> +static const struct net_device_ops parent_netdev_ops = {
> + .ndo_init = parent_init,
> + .ndo_uninit = parent_uninit,
> + .ndo_open = parent_open,
> + .ndo_stop = parent_close,
> + .ndo_start_xmit = parent_tx,
> + .ndo_select_queue = parent_select_q,
> + /* parnt mtu is min(slaves_mtus) */
> + .ndo_change_mtu = NULL,
> + .ndo_fix_features = parent_fix_features,
> + /*
> + * initial mac address is randomized, can be changed
> + * thru this func later
> + */
> + .ndo_set_mac_address = eth_mac_addr,
> + .ndo_get_stats = parent_get_stats,
>
> Why not implement ndo_get_stats64? I don't think there's any good
> reason for a new driver not to.
Indeed, will do ndo_get_stats64
>
>
>> + .ndo_vlan_rx_add_vid = eth_ipoib_vlan_rx_add_vid,
>> + .ndo_vlan_rx_kill_vid = eth_ipoib_vlan_rx_kill_vid,
>
> These shouldn't be needed.
ok, here's the point, the eIPoIB driver maps Ethernet vlans to
infiniband/IPoIB pkeys
(partition keys). The underlying IPoIB devices work with these pkeys
in a way which is HW accelerated, and we want the eIPoIB driver to be
considered as one
that support HW accelerate vlans. E.g on the TX flow we don't want that
any special SW
handling by the 8021q driver will be done on the skb except for setting
the skb->vlan_tci
field, and in the RX flow, we set skb->vlan_tci field and don't want
that 8021q to try
and extract it from the headers, etc.
For that end, I was under the impression all the three
NETIF_F_HW_VLAN_{TX,RX,FILTER)
features need to be advertized. From your comment I understand now that
RX/TX are enough
in that respect?
>
>
> [...]
>> +/* netdev events handlers */
>> +static inline int is_ipoib_pif_intf(struct net_device *dev)
>> +{
>> + if (ARPHRD_INFINIBAND == dev->type && dev->priv_flags & IFF_EIPOIB_PIF)
>> + return 1;
> [...]
>
> Wrong indentation.
will fix, thanks for spotting this.
Or.
^ permalink raw reply
* Re: [PATCH net-next] ipv4: tcp: remove per net tcp_sock
From: David Miller @ 2012-07-19 15:45 UTC (permalink / raw)
To: eric.dumazet; +Cc: netdev, therbert, wsommerfeld
In-Reply-To: <20120719.083544.1223522161508413373.davem@davemloft.net>
From: David Miller <davem@davemloft.net>
Date: Thu, 19 Jul 2012 08:35:44 -0700 (PDT)
> Looks great, applied, thanks Eric.
I take that back, it doesn't build:
net/ipv4/ip_output.c: In function ‘ip_send_unicast_reply’:
net/ipv4/ip_output.c:1481:1: error: section attribute cannot be specified for local variables
net/ipv4/ip_output.c:1481:1: error: section attribute cannot be specified for local variables
net/ipv4/ip_output.c:1481:1: error: declaration of ‘__pcpu_unique_unicast_sock’ with no linkage follows extern declaration
net/ipv4/ip_output.c:1481:1: note: previous declaration of ‘__pcpu_unique_unicast_sock’ was here
net/ipv4/ip_output.c:1481:9: error: section attribute cannot be specified for local variables
net/ipv4/ip_output.c:1481:9: error: weak declaration of ‘unicast_sock’ must be public
^ permalink raw reply
* Re: [PATCH net-next 4/7] sfc: Add support for IEEE-1588 PTP
From: David Miller @ 2012-07-19 15:43 UTC (permalink / raw)
To: smhodgson; +Cc: richardcochran, bhutchings, netdev, linux-net-drivers, ajackson
In-Reply-To: <500827EF.208@solarflare.com>
I really wish we hadn't started quoting an entire HUGE patch file
in this discussion.
Only quote the relevant snippets of the patch for the purposes of
the discussion when replying, thank you.
^ permalink raw reply
* solar lala shared photos with you
From: solar lala @ 2012-07-19 15:41 UTC (permalink / raw)
To: netdev
[-- Attachment #1: Type: text/plain, Size: 437 bytes --]
Dear sir
We supply solar PV system (including solar panels , frame,
cable ,inverter and controller , power distribution cabinet) with
1.6$/w FOB shenzhen.
Email me or just call me directly if needed. Thank you!
Best wishes
lala
Ecosol PV Tech Co., Ltd
Tel: 86-769-8279 2468
Fax: 86-769-879 2478
email:info@ecsolsolar.com
skype:solarlala
msn:solarlala@hotmail.com
www.ecsolsolar.com
[-- Attachment #2: 003.jpg --]
[-- Type: image/jpeg, Size: 8290 bytes --]
^ permalink raw reply
* Re: [PATCH 09/15] ipv4: Cache output routes in fib_info nexthops.
From: David Miller @ 2012-07-19 15:39 UTC (permalink / raw)
To: steffen.klassert; +Cc: netdev
In-Reply-To: <20120719113810.GM1869@secunet.com>
From: Steffen Klassert <steffen.klassert@secunet.com>
Date: Thu, 19 Jul 2012 13:38:10 +0200
> On Wed, Jul 18, 2012 at 11:24:04AM -0700, David Miller wrote:
>> +
>> +static void rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe)
>> +{
>> + if (fnhe->fnhe_pmtu) {
>> + unsigned long expires = fnhe->fnhe_expires;
>> + unsigned long diff = jiffies - expires;
>
> This should be diff = expires - jiffies
>
> With that changed, everything seems to work fine :)
Thanks a lot for catching this bug, I'll fix it up right now.
^ permalink raw reply
* Re: [PATCH] net: e100: ucode is optional in some cases
From: David Miller @ 2012-07-19 15:37 UTC (permalink / raw)
To: bjorn
Cc: netdev, jeffrey.t.kirsher, jesse.brandeburg, bruce.w.allan,
carolyn.wyborny, donald.c.skidmore, gregory.v.rose,
peter.p.waskiewicz.jr, alexander.h.duyck, john.ronciak,
e1000-devel
In-Reply-To: <1342690393-18459-1-git-send-email-bjorn@mork.no>
From: Bjørn Mork <bjorn@mork.no>
Date: Thu, 19 Jul 2012 11:33:13 +0200
> + * http://www.freebsd.org/cgi/cvsweb.cgi/src/sys/dev/fxp/rcvbundl.h?rev=HEAD;content-type=text%2Fplain
Please don't put URLs into the source code, they generally lack
permanence.
^ permalink raw reply
* Re: [PATCH net-next] ipv4: tcp: remove per net tcp_sock
From: David Miller @ 2012-07-19 15:35 UTC (permalink / raw)
To: eric.dumazet; +Cc: netdev, therbert, wsommerfeld
In-Reply-To: <1342688332.2626.4001.camel@edumazet-glaptop>
From: Eric Dumazet <eric.dumazet@gmail.com>
Date: Thu, 19 Jul 2012 10:58:52 +0200
> From: Eric Dumazet <edumazet@google.com>
>
> tcp_v4_send_reset() and tcp_v4_send_ack() use a single socket
> per network namespace.
>
> This leads to bad behavior on multiqueue NICS, because many cpus
> contend for the socket lock and once socket lock is acquired, extra
> false sharing on various socket fields slow down the operations.
>
> To better resist to attacks, we use a percpu socket. Each cpu can
> run without contention, using appropriate memory (local node)
>
> Additional features :
>
> 1) We also mirror the queue_mapping of the incoming skb, so that
> answers use the same queue if possible.
>
> 2) Setting SOCK_USE_WRITE_QUEUE socket flag speedup sock_wfree()
>
> 3) We now limit the number of in-flight RST/ACK [1] packets
> per cpu, instead of per namespace, and we honor the sysctl_wmem_default
> limit dynamically. (Prior to this patch, sysctl_wmem_default value was
> copied at boot time, so any further change would not affect tcp_sock
> limit)
>
>
> [1] These packets are only generated when no socket was matched for
> the incoming packet.
>
> Reported-by: Bill Sommerfeld <wsommerfeld@google.com>
> Signed-off-by: Eric Dumazet <edumazet@google.com>
Looks great, applied, thanks Eric.
> @@ -2624,13 +2624,11 @@ EXPORT_SYMBOL(tcp_prot);
>
> static int __net_init tcp_sk_init(struct net *net)
> {
> - return inet_ctl_sock_create(&net->ipv4.tcp_sock,
> - PF_INET, SOCK_RAW, IPPROTO_TCP, net);
> + return 0;
> }
>
> static void __net_exit tcp_sk_exit(struct net *net)
> {
> - inet_ctl_sock_destroy(net->ipv4.tcp_sock);
> }
>
> static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
If these no longer really do anything, just send me a patch to kill
them off entirely.
Thanks again.
^ permalink raw reply
* Re: [PATCH net-next V1 0/4] net/mlx4_en: Add accelerated RFS support
From: David Miller @ 2012-07-19 15:34 UTC (permalink / raw)
To: ogerlitz; +Cc: roland, netdev, oren, yevgenyp, amirv
In-Reply-To: <1342686832-21406-1-git-send-email-ogerlitz@mellanox.com>
From: Or Gerlitz <ogerlitz@mellanox.com>
Date: Thu, 19 Jul 2012 11:33:48 +0300
> This series from Amir Vadai adds support for Accelerated RFS
> to the mlx4_en Ethernet driver.
>
> The code uses the Accelerated RFS infrastructure and HW flow steering
> to keep CPU affinity of rx interrupts and applications per TCP stream.
>
> To do so, we had to add little protection to cpu_rmap.h against double
> inclusion. Also, added linking between CPU to IRQ using rmap in the
> mlx4_core driver.
>
> changes from V0:
> - always use CONFIG_RFS_ACCEL instead of using twice CONFIG_CPU_RMAP directly
Series applied, thanks.
^ permalink raw reply
* Re: [PATCH] ipv4: fix address selection in fib_compute_spec_dst
From: David Miller @ 2012-07-19 15:31 UTC (permalink / raw)
To: ja; +Cc: netdev
In-Reply-To: <1342683303-3557-1-git-send-email-ja@ssi.bg>
From: Julian Anastasov <ja@ssi.bg>
Date: Thu, 19 Jul 2012 10:35:03 +0300
> ip_options_compile can be called for forwarded packets,
> make sure the specific-destionation address is a local one as
> specified in RFC 1812, 4.2.2.2 Addresses in Options
>
> Signed-off-by: Julian Anastasov <ja@ssi.bg>
Applied.
^ permalink raw reply
* Re: [PATCH] ipv4: optimize fib_compute_spec_dst call in ip_options_echo
From: David Miller @ 2012-07-19 15:30 UTC (permalink / raw)
To: ja; +Cc: netdev
In-Reply-To: <1342683264-3523-1-git-send-email-ja@ssi.bg>
From: Julian Anastasov <ja@ssi.bg>
Date: Thu, 19 Jul 2012 10:34:24 +0300
> Move fib_compute_spec_dst at the only place where it
> is needed.
>
> Signed-off-by: Julian Anastasov <ja@ssi.bg>
Applied.
^ permalink raw reply
* Re: [PATCH net-next 4/7] sfc: Add support for IEEE-1588 PTP
From: Stuart Hodgson @ 2012-07-19 15:29 UTC (permalink / raw)
To: Richard Cochran
Cc: Ben Hutchings, David Miller, netdev, linux-net-drivers,
Andrew Jackson
In-Reply-To: <20120719142558.GB24484@localhost.localdomain>
On 19/07/12 15:25, Richard Cochran wrote:
> On Wed, Jul 18, 2012 at 07:21:33PM +0100, Ben Hutchings wrote:
>> Add PTP IEEE-1588 support and make accesible via the PHC subsystem.
>>
>> This work is based on prior code by Andrew Jackson
>>
>> Signed-off-by: Stuart Hodgson <smhodgson@solarflare.com>
>> Signed-off-by: Ben Hutchings <bhutchings@solarflare.com>
>> ---
>> drivers/net/ethernet/sfc/Kconfig | 7 +
>> drivers/net/ethernet/sfc/Makefile | 1 +
>> drivers/net/ethernet/sfc/efx.c | 3 +
>> drivers/net/ethernet/sfc/ethtool.c | 1 +
>> drivers/net/ethernet/sfc/mcdi_pcol.h | 1 +
>> drivers/net/ethernet/sfc/net_driver.h | 19 +-
>> drivers/net/ethernet/sfc/nic.h | 31 +
>> drivers/net/ethernet/sfc/ptp.c | 1519 +++++++++++++++++++++++++++++++++
>> drivers/net/ethernet/sfc/rx.c | 2 +-
>> drivers/net/ethernet/sfc/siena.c | 1 +
>> drivers/net/ethernet/sfc/tx.c | 6 +
>> 11 files changed, 1589 insertions(+), 2 deletions(-)
>> create mode 100644 drivers/net/ethernet/sfc/ptp.c
>>
>> diff --git a/drivers/net/ethernet/sfc/Kconfig b/drivers/net/ethernet/sfc/Kconfig
>> index fb3cbc2..78c5d435 100644
>> --- a/drivers/net/ethernet/sfc/Kconfig
>> +++ b/drivers/net/ethernet/sfc/Kconfig
>> @@ -34,3 +34,10 @@ config SFC_SRIOV
>> This enables support for the SFC9000 I/O Virtualization
>> features, allowing accelerated network performance in
>> virtualized environments.
>> +config SFC_PTP
>> + bool "Solarflare SFC9000-family PTP support"
>> + depends on SFC && PTP_1588_CLOCK
>> + default y
>> + ---help---
>> + This enables support for the Precision Time Protocol (PTP)
>> + on SFC9000-family NICs
>> diff --git a/drivers/net/ethernet/sfc/Makefile b/drivers/net/ethernet/sfc/Makefile
>> index ea1f8db..e11f2ec 100644
>> --- a/drivers/net/ethernet/sfc/Makefile
>> +++ b/drivers/net/ethernet/sfc/Makefile
>> @@ -5,5 +5,6 @@ sfc-y += efx.o nic.o falcon.o siena.o tx.o rx.o filter.o \
>> mcdi.o mcdi_phy.o mcdi_mon.o
>> sfc-$(CONFIG_SFC_MTD) += mtd.o
>> sfc-$(CONFIG_SFC_SRIOV) += siena_sriov.o
>> +sfc-$(CONFIG_SFC_PTP) += ptp.o
>>
>> obj-$(CONFIG_SFC) += sfc.o
>> diff --git a/drivers/net/ethernet/sfc/efx.c b/drivers/net/ethernet/sfc/efx.c
>> index 1c53d4b..e6631f0e 100644
>> --- a/drivers/net/ethernet/sfc/efx.c
>> +++ b/drivers/net/ethernet/sfc/efx.c
>> @@ -1748,6 +1748,9 @@ static int efx_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
>>
>> EFX_ASSERT_RESET_SERIALISED(efx);
>>
>> + if (cmd == SIOCSHWTSTAMP)
>> + return efx_ptp_ioctl(efx, ifr, cmd);
>> +
>> /* Convert phy_id from older PRTAD/DEVAD format */
>> if ((cmd == SIOCGMIIREG || cmd == SIOCSMIIREG) &&
>> (data->phy_id & 0xfc00) == 0x0400)
>> diff --git a/drivers/net/ethernet/sfc/ethtool.c b/drivers/net/ethernet/sfc/ethtool.c
>> index 10536f9..50cdd39 100644
>> --- a/drivers/net/ethernet/sfc/ethtool.c
>> +++ b/drivers/net/ethernet/sfc/ethtool.c
>> @@ -1170,6 +1170,7 @@ const struct ethtool_ops efx_ethtool_ops = {
>> .get_rxfh_indir_size = efx_ethtool_get_rxfh_indir_size,
>> .get_rxfh_indir = efx_ethtool_get_rxfh_indir,
>> .set_rxfh_indir = efx_ethtool_set_rxfh_indir,
>> + .get_ts_info = efx_ptp_get_ts_info,
>> .get_module_info = efx_ethtool_get_module_info,
>> .get_module_eeprom = efx_ethtool_get_module_eeprom,
>> };
>> diff --git a/drivers/net/ethernet/sfc/mcdi_pcol.h b/drivers/net/ethernet/sfc/mcdi_pcol.h
>> index 0310b9f0..0017f98 100644
>> --- a/drivers/net/ethernet/sfc/mcdi_pcol.h
>> +++ b/drivers/net/ethernet/sfc/mcdi_pcol.h
>> @@ -290,6 +290,7 @@
>> #define MCDI_EVENT_CODE_TX_FLUSH 0xc /* enum */
>> #define MCDI_EVENT_CODE_PTP_RX 0xd /* enum */
>> #define MCDI_EVENT_CODE_PTP_FAULT 0xe /* enum */
>> +#define MCDI_EVENT_CODE_PTP_PPS 0xf /* enum */
>> #define MCDI_EVENT_CMDDONE_DATA_OFST 0
>> #define MCDI_EVENT_CMDDONE_DATA_LBN 0
>> #define MCDI_EVENT_CMDDONE_DATA_WIDTH 32
>> diff --git a/drivers/net/ethernet/sfc/net_driver.h b/drivers/net/ethernet/sfc/net_driver.h
>> index 9913e32..f84a5d5 100644
>> --- a/drivers/net/ethernet/sfc/net_driver.h
>> +++ b/drivers/net/ethernet/sfc/net_driver.h
>> @@ -56,7 +56,8 @@
>> #define EFX_MAX_CHANNELS 32U
>> #define EFX_MAX_RX_QUEUES EFX_MAX_CHANNELS
>> #define EFX_EXTRA_CHANNEL_IOV 0
>> -#define EFX_MAX_EXTRA_CHANNELS 1U
>> +#define EFX_EXTRA_CHANNEL_PTP 1
>> +#define EFX_MAX_EXTRA_CHANNELS 2U
>>
>> /* Checksum generation is a per-queue option in hardware, so each
>> * queue visible to the networking core is backed by two hardware TX
>> @@ -68,6 +69,9 @@
>> #define EFX_TXQ_TYPES 4
>> #define EFX_MAX_TX_QUEUES (EFX_TXQ_TYPES * EFX_MAX_CHANNELS)
>>
>> +/* Forward declare Precision Time Protocol (PTP) support structure. */
>> +struct efx_ptp_data;
>> +
>> struct efx_self_tests;
>>
>> /**
>> @@ -736,6 +740,7 @@ struct vfdi_status;
>> * %local_addr_list. Protected by %local_lock.
>> * @local_lock: Mutex protecting %local_addr_list and %local_page_list.
>> * @peer_work: Work item to broadcast peer addresses to VMs.
>> + * @ptp_data: PTP state data
>> * @monitor_work: Hardware monitor workitem
>> * @biu_lock: BIU (bus interface unit) lock
>> * @last_irq_cpu: Last CPU to handle a possible test interrupt. This
>> @@ -860,6 +865,10 @@ struct efx_nic {
>> struct work_struct peer_work;
>> #endif
>>
>> +#ifdef CONFIG_SFC_PTP
>> + struct efx_ptp_data *ptp_data;
>> +#endif
>> +
>> /* The following fields may be written more often */
>>
>> struct delayed_work monitor_work ____cacheline_aligned_in_smp;
>> @@ -1122,5 +1131,13 @@ static inline void clear_bit_le(unsigned nr, unsigned char *addr)
>> #define EFX_MAX_FRAME_LEN(mtu) \
>> ((((mtu) + ETH_HLEN + VLAN_HLEN + 4/* FCS */ + 7) & ~7) + 16)
>>
>> +static inline bool efx_xmit_with_hwtstamp(struct sk_buff *skb)
>> +{
>> + return skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP;
>> +}
>> +static inline void efx_xmit_hwtstamp_pending(struct sk_buff *skb)
>> +{
>> + skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
>> +}
>>
>> #endif /* EFX_NET_DRIVER_H */
>> diff --git a/drivers/net/ethernet/sfc/nic.h b/drivers/net/ethernet/sfc/nic.h
>> index bab5cd9..cd53ab5 100644
>> --- a/drivers/net/ethernet/sfc/nic.h
>> +++ b/drivers/net/ethernet/sfc/nic.h
>> @@ -250,6 +250,37 @@ extern int efx_sriov_get_vf_config(struct net_device *dev, int vf,
>> extern int efx_sriov_set_vf_spoofchk(struct net_device *net_dev, int vf,
>> bool spoofchk);
>>
>> +struct ethtool_ts_info;
>> +#ifdef CONFIG_SFC_PTP
>> +extern void efx_ptp_probe(struct efx_nic *efx);
>> +extern int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd);
>> +extern int efx_ptp_get_ts_info(struct net_device *net_dev,
>> + struct ethtool_ts_info *ts_info);
>> +extern bool efx_ptp_is_ptp_tx(struct efx_nic *efx, struct sk_buff *skb);
>> +extern int efx_ptp_tx(struct efx_nic *efx, struct sk_buff *skb);
>> +extern void efx_ptp_event(struct efx_nic *efx, efx_qword_t *ev);
>> +#else
>> +static inline void efx_ptp_probe(struct efx_nic *efx) {}
>> +static inline int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd)
>> +{
>> + return -EOPNOTSUPP;
>> +}
>> +static inline int efx_ptp_get_ts_info(struct net_device *net_dev,
>> + struct ethtool_ts_info *ts_info)
>> +{
>> + return -EOPNOTSUPP;
>
> If your PTP support is not enabled, then it would be better to offer
> the standard ethtool answer to this query.
>
> Also, it would be nice to still offer SW Tx timestamping, even when
> PTP is disabled.
>
>> +}
>> +static inline bool efx_ptp_is_ptp_tx(struct efx_nic *efx, struct sk_buff *skb)
>> +{
>> + return false;
>> +}
>> +static inline int efx_ptp_tx(struct efx_nic *efx, struct sk_buff *skb)
>> +{
>> + return NETDEV_TX_OK;
>> +}
>> +static inline void efx_ptp_event(struct efx_nic *efx, efx_qword_t *ev) {}
>> +#endif
>> +
>> extern const struct efx_nic_type falcon_a1_nic_type;
>> extern const struct efx_nic_type falcon_b0_nic_type;
>> extern const struct efx_nic_type siena_a0_nic_type;
>> diff --git a/drivers/net/ethernet/sfc/ptp.c b/drivers/net/ethernet/sfc/ptp.c
>> new file mode 100644
>> index 0000000..ba1e76a
>> --- /dev/null
>> +++ b/drivers/net/ethernet/sfc/ptp.c
>> @@ -0,0 +1,1519 @@
>> +/****************************************************************************
>> + * Driver for Solarflare Solarstorm network controllers and boards
>> + * Copyright 2011 Solarflare Communications Inc.
>> + *
>> + * This program is free software; you can redistribute it and/or modify it
>> + * under the terms of the GNU General Public License version 2 as published
>> + * by the Free Software Foundation, incorporated herein by reference.
>> + */
>> +
>> +/* Theory of operation:
>> + *
>> + * PTP support is assisted by firmware running on the MC, which provides
>> + * the hardware timestamping capabilities. Both transmitted and received
>> + * PTP event packets are queued onto internal queues for subsequent processing;
>> + * this is because the MC operations are relatively long and would block
>> + * block NAPI/interrupt operation.
>> + *
>> + * Receive event processing:
>> + * The event contains the packet's UUID and sequence number, together
>> + * with the hardware timestamp. The PTP receive packet queue is searched
>> + * for this UUID/sequence number and, if found, put on a pending queue.
>> + * Packets not matching are delivered without timestamps (MCDI events will
>> + * always arrive after the actual packet).
>> + * It is important for the operation of the PTP protocol that the ordering
>> + * of packets between the event and general port is maintained.
>> + *
>> + * Work queue processing:
>> + * If work waiting, synchronise host/hardware time
>> + *
>> + * Transmit: send packet through MC, which returns the transmission time
>> + * that is converted to an appropriate timestamp.
>> + *
>> + * Receive: the packet's reception time is converted to an appropriate
>> + * timestamp.
>> + */
>> +#include <linux/ip.h>
>> +#include <linux/udp.h>
>> +#include <linux/time.h>
>> +#include <linux/ktime.h>
>> +#include <linux/module.h>
>> +#include <linux/net_tstamp.h>
>> +#include <linux/ptp_clock_kernel.h>
>> +#include "net_driver.h"
>> +#include "efx.h"
>> +#include "mcdi.h"
>> +#include "mcdi_pcol.h"
>> +#include "io.h"
>> +#include "regs.h"
>> +#include "nic.h"
>> +
>> +/* Maximum number of events expected to make up a PTP event */
>> +#define MAX_EVENT_FRAGS 3
>> +
>> +/* Maximum delay, ms, to begin synchronisation */
>> +#define MAX_SYNCHRONISE_WAIT_MS 2
>> +
>> +/* How long, at most, to spend synchronising */
>> +#define SYNCHRONISE_PERIOD_NS 250000
>> +
>> +/* How often to update the shared memory time */
>> +#define SYNCHRONISATION_GRANULARITY_NS 200
>> +
>> +/* Minimum permitted length of a (corrected) synchronisation time */
>> +#define MIN_SYNCHRONISATION_NS 120
>> +
>> +/* Maximum permitted length of a (corrected) synchronisation time */
>> +#define MAX_SYNCHRONISATION_NS 1000
>> +
>> +/* How many (MC) receive events that can be queued */
>> +#define MAX_RECEIVE_EVENTS 8
>> +
>> +/* Length of (modified) moving average. */
>> +#define AVERAGE_LENGTH 16
>> +
>> +/* How long an unmatched event or packet can be held */
>> +#define PKT_EVENT_LIFETIME_MS 10
>> +
>> +/* Offsets into PTP packet for identification. These offsets are from the
>> + * start of the IP header, not the MAC header. Note that neither PTP V1 nor
>> + * PTP V2 permit the use of IPV4 options.
>> + */
>> +#define PTP_DPORT_OFFSET 22
>> +
>> +#define PTP_V1_VERSION_LENGTH 2
>> +#define PTP_V1_VERSION_OFFSET 28
>> +
>> +#define PTP_V1_UUID_LENGTH 6
>> +#define PTP_V1_UUID_OFFSET 50
>> +
>> +#define PTP_V1_SEQUENCE_LENGTH 2
>> +#define PTP_V1_SEQUENCE_OFFSET 58
>> +
>> +/* The minimum length of a PTP V1 packet for offsets, etc. to be valid:
>> + * includes IP header.
>> + */
>> +#define PTP_V1_MIN_LENGTH 64
>> +
>> +#define PTP_V2_VERSION_LENGTH 1
>> +#define PTP_V2_VERSION_OFFSET 29
>> +
>> +/* Although PTP V2 UUIDs are comprised a ClockIdentity (8) and PortNumber (2),
>> + * the MC only captures the last six bytes of the clock identity. These values
>> + * reflect those, not the ones used in the standard. The standard permits
>> + * mapping of V1 UUIDs to V2 UUIDs with these same values.
>> + */
>> +#define PTP_V2_MC_UUID_LENGTH 6
>> +#define PTP_V2_MC_UUID_OFFSET 50
>> +
>> +#define PTP_V2_SEQUENCE_LENGTH 2
>> +#define PTP_V2_SEQUENCE_OFFSET 58
>> +
>> +/* The minimum length of a PTP V2 packet for offsets, etc. to be valid:
>> + * includes IP header.
>> + */
>> +#define PTP_V2_MIN_LENGTH 63
>> +
>> +#define PTP_MIN_LENGTH 63
>> +
>> +#define PTP_ADDRESS 0xe0000181 /* 224.0.1.129 */
>> +#define PTP_EVENT_PORT 319
>> +#define PTP_GENERAL_PORT 320
>> +
>> +/* Annoyingly the format of the version numbers are different between
>> + * versions 1 and 2 so it isn't possible to simply look for 1 or 2.
>> + */
>> +#define PTP_VERSION_V1 1
>> +
>> +#define PTP_VERSION_V2 2
>> +#define PTP_VERSION_V2_MASK 0x0f
>> +
>> +enum ptp_packet_state {
>> + PTP_PACKET_STATE_UNMATCHED = 0,
>> + PTP_PACKET_STATE_MATCHED,
>> + PTP_PACKET_STATE_TIMED_OUT,
>> + PTP_PACKET_STATE_MATCH_UNWANTED
>> +};
>> +
>> +/* NIC synchronised with single word of time only comprising
>> + * partial seconds and full nanoseconds: 10^9 ~ 2^30 so 2 bits for seconds.
>> + */
>> +#define MC_NANOSECOND_BITS 30
>> +#define MC_NANOSECOND_MASK ((1 << MC_NANOSECOND_BITS) - 1)
>> +#define MC_SECOND_MASK ((1 << (32 - MC_NANOSECOND_BITS)) - 1)
>> +
>> +/* Maximum parts-per-billion adjustment that is acceptable */
>> +#define MAX_PPB 1000000
>> +
>> +/* Number of bits required to hold the above */
>> +#define MAX_PPB_BITS 20
>> +
>> +/* Number of extra bits allowed when calculating fractional ns.
>> + * EXTRA_BITS + MC_CMD_PTP_IN_ADJUST_BITS + MAX_PPB_BITS should
>> + * be less than 63.
>> + */
>> +#define PPB_EXTRA_BITS 2
>> +
>> +/* Precalculate scale word to avoid long long division at runtime */
>> +#define PPB_SCALE_WORD ((1LL << (PPB_EXTRA_BITS + MC_CMD_PTP_IN_ADJUST_BITS +\
>> + MAX_PPB_BITS)) / 1000000000LL)
>> +
>> +#define PTP_SYNC_ATTEMPTS 4
>> +
>> +/**
>> + * struct efx_ptp_match - Matching structure, stored in sk_buff's cb area.
>> + * @words: UUID and (partial) sequence number
>> + * @expiry: Time after which the packet should be delivered irrespective of
>> + * event arrival.
>> + * @state: The state of the packet - whether it is ready for processing or
>> + * whether that is of no interest.
>> + */
>> +struct efx_ptp_match {
>> + u32 words[DIV_ROUND_UP(PTP_V1_UUID_LENGTH, 4)];
>> + unsigned long expiry;
>> + enum ptp_packet_state state;
>> +};
>> +
>> +/**
>> + * struct efx_ptp_event_rx - A PTP receive event (from MC)
>> + * @seq0: First part of (PTP) UUID
>> + * @seq1: Second part of (PTP) UUID and sequence number
>> + * @hwtimestamp: Event timestamp
>> + */
>> +struct efx_ptp_event_rx {
>> + struct list_head link;
>> + u32 seq0;
>> + u32 seq1;
>> + ktime_t hwtimestamp;
>> + unsigned long expiry;
>> +};
>> +
>> +/**
>> + * struct efx_ptp_timeset - Synchronisation between host and MC
>> + * @host_start: Host time immediately before hardware timestamp taken
>> + * @seconds: Hardware timestamp, seconds
>> + * @nanoseconds: Hardware timestamp, nanoseconds
>> + * @host_end: Host time immediately after hardware timestamp taken
>> + * @waitns: Number of nanoseconds between hardware timestamp being read and
>> + * host end time being seen
>> + * @window: Difference of host_end and host_start
>> + * @valid: Whether this timeset is valid
>> + */
>> +struct efx_ptp_timeset {
>> + u32 host_start;
>> + u32 seconds;
>> + u32 nanoseconds;
>> + u32 host_end;
>> + u32 waitns;
>> + u32 window; /* Derived: end - start, allowing for wrap */
>> +};
>> +
>> +/**
>> + * struct efx_ptp_data - Precision Time Protocol (PTP) state
>> + * @channel: The PTP channel
>> + * @rxq: Receive queue (awaiting timestamps)
>> + * @txq: Transmit queue
>> + * @evt_list: List of MC receive events awaiting packets
>> + * @evt_free_list: List of free events
>> + * @evt_lock: Lock for manipulating evt_list and evt_free_list
>> + * @rx_evts: Instantiated events (on evt_list and evt_free_list)
>> + * @workwq: Work queue for processing pending PTP operations
>> + * @work: Work task
>> + * @reset_required: A serious error has occurred and the PTP task needs to be
>> + * reset (disable, enable).
>> + * @rxfilter_event: Receive filter when operating
>> + * @rxfilter_general: Receive filter when operating
>> + * @config: Current timestamp configuration
>> + * @enabled: PTP operation enabled
>> + * @mode: Mode in which PTP operating (PTP version)
>> + * @evt_frags: Partly assembled PTP events
>> + * @evt_frag_idx: Current fragment number
>> + * @evt_code: Last event code
>> + * @start: Address at which MC indicates ready for synchronisation
>> + * @host_base_time: (Synchronised with mc_base_time) host time
>> + * @mc_base_time: (Synchronised with host_base_time) MC/hardware time
>> + * @base_time_valid: Whether host_base_time and mc_base_time are synchronised
>> + * @last_sync_ns: Last number of nanoseconds between readings when synchronising
>> + * @base_sync_ns: Number of nanoseconds for last synchronisation.
>> + * @base_sync_valid: Whether base_sync_time is valid.
>> + * @current_adjfreq: Current ppb adjustment.
>> + * @phc_clock: Pointer to registered phc device
>> + * @phc_clock_info: Registration structure for phc device
>> + * @pps_work: pps work task for handling pps events
>> + * @pps_workwq: pps work queue
>> + * @nic_ts_enabled: Flag indicating if NIC generated TS events are handled
>> + * @txbuf: Buffer for use when transmitting (PTP) packets to MC (avoids
>> + * allocations in main data path).
>> + * @debug_ptp_dir: PTP debugfs directory
>> + * @missed_rx_sync: Number of packets received without syncrhonisation.
>> + * @good_syncs: Number of successful synchronisations.
>> + * @no_time_syncs: Number of synchronisations with no good times.
>> + * @bad_sync_durations: Number of synchronisations with bad durations.
>> + * @bad_syncs: Number of failed synchronisations.
>> + * @last_sync_time: Number of nanoseconds for last synchronisation.
>> + * @sync_timeouts: Number of synchronisation timeouts
>> + * @fast_syncs: Number of synchronisations requiring short delay
>> + * @min_sync_delta: Minimum time between event and synchronisation
>> + * @max_sync_delta: Maximum time between event and synchronisation
>> + * @average_sync_delta: Average time between event and synchronisation.
>> + * Modified moving average.
>> + * @last_sync_delta: Last time between event and synchronisation
>> + * @mc_stats: Context value for MC statistics
>> + * @timeset: Last set of synchronisation statistics.
>> + */
>> +struct efx_ptp_data {
>> + struct efx_channel *channel;
>> + struct sk_buff_head rxq;
>> + struct sk_buff_head txq;
>> + struct list_head evt_list;
>> + struct list_head evt_free_list;
>> + spinlock_t evt_lock;
>> + struct efx_ptp_event_rx rx_evts[MAX_RECEIVE_EVENTS];
>> + struct workqueue_struct *workwq;
>> + struct work_struct work;
>> + bool reset_required;
>> + u32 rxfilter_event;
>> + u32 rxfilter_general;
>> + bool rxfilter_installed;
>> + struct hwtstamp_config config;
>> + bool enabled;
>> + unsigned int mode;
>> + efx_qword_t evt_frags[MAX_EVENT_FRAGS];
>> + int evt_frag_idx;
>> + int evt_code;
>> + struct efx_buffer start;
>> + ktime_t host_base_time;
>> + ktime_t mc_base_time;
>> + bool base_time_valid;
>> + unsigned last_sync_ns;
>> + unsigned base_sync_ns;
>> + bool base_sync_valid;
>> + s64 current_adjfreq;
>> + struct ptp_clock *phc_clock;
>> + struct ptp_clock_info phc_clock_info;
>> + struct work_struct pps_work;
>> + struct workqueue_struct *pps_workwq;
>> + bool nic_ts_enabled;
>> + u8 txbuf[ALIGN(MC_CMD_PTP_IN_TRANSMIT_LEN(
>> + MC_CMD_PTP_IN_TRANSMIT_PACKET_MAXNUM), 4)];
>> + struct efx_ptp_timeset
>> + timeset[MC_CMD_PTP_OUT_SYNCHRONIZE_TIMESET_MAXNUM];
>> +};
>> +
>> +static int efx_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta);
>> +static int efx_phc_adjtime(struct ptp_clock_info *ptp, s64 delta);
>> +static int efx_phc_gettime(struct ptp_clock_info *ptp, struct timespec *ts);
>> +static int efx_phc_settime(struct ptp_clock_info *ptp,
>> + const struct timespec *e_ts);
>> +static int efx_phc_enable(struct ptp_clock_info *ptp,
>> + struct ptp_clock_request *request, int on);
>> +
>> +/* Enable MCDI PTP support. */
>> +static int efx_ptp_enable(struct efx_nic *efx)
>> +{
>> + u8 inbuf[MC_CMD_PTP_IN_ENABLE_LEN];
>> +
>> + MCDI_SET_DWORD(inbuf, PTP_IN_OP, MC_CMD_PTP_OP_ENABLE);
>> + MCDI_SET_DWORD(inbuf, PTP_IN_ENABLE_QUEUE,
>> + efx->ptp_data->channel->channel);
>> + MCDI_SET_DWORD(inbuf, PTP_IN_ENABLE_MODE, efx->ptp_data->mode);
>> +
>> + return efx_mcdi_rpc(efx, MC_CMD_PTP, inbuf, sizeof(inbuf),
>> + NULL, 0, NULL);
>> +}
>> +
>> +/* Disable MCDI PTP support.
>> + *
>> + * Note that this function should never rely on the presence of ptp_data -
>> + * may be called before that exists.
>> + */
>> +static int efx_ptp_disable(struct efx_nic *efx)
>> +{
>> + u8 inbuf[MC_CMD_PTP_IN_DISABLE_LEN];
>> +
>> + MCDI_SET_DWORD(inbuf, PTP_IN_OP, MC_CMD_PTP_OP_DISABLE);
>> + return efx_mcdi_rpc(efx, MC_CMD_PTP, inbuf, sizeof(inbuf),
>> + NULL, 0, NULL);
>> +}
>> +
>> +static void efx_ptp_deliver_rx_queue(struct sk_buff_head *q)
>> +{
>> + struct sk_buff *skb;
>> +
>> + while ((skb = skb_dequeue(q))) {
>> + local_bh_disable();
>> + netif_receive_skb(skb);
>> + local_bh_enable();
>> + }
>> +}
>> +
>> +static void efx_ptp_handle_no_channel(struct efx_nic *efx)
>> +{
>> + netif_err(efx, drv, efx->net_dev,
>> + "ERROR: PTP requires MSI-X and 1 additional interrupt"
>> + "vector. PTP disabled\n");
>> +}
>> +
>> +/* Repeatedly send the host time to the MC which will capture the hardware
>> + * time.
>> + */
>> +static void efx_ptp_send_times(struct efx_nic *efx, struct timespec *last_time)
>> +{
>> + struct timespec now;
>> + struct timespec limit;
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + struct timespec start;
>> + int *mc_running = ptp->start.addr;
>> +
>> + getnstimeofday(&now);
>> + start = now;
>> + limit = now;
>> + timespec_add_ns(&limit, SYNCHRONISE_PERIOD_NS);
>> +
>> + /* Write host time for specified period or until MC is done */
>> + while ((timespec_compare(&now, &limit) < 0) &&
>> + ACCESS_ONCE(*mc_running)) {
>> + struct timespec update_time;
>> + unsigned int host_time;
>> +
>> + /* Don't update continuously to avoid saturating the PCIe bus */
>> + update_time = now;
>> + timespec_add_ns(&update_time, SYNCHRONISATION_GRANULARITY_NS);
>> + do {
>> + getnstimeofday(&now);
>> + } while ((timespec_compare(&now, &update_time) < 0) &&
>> + ACCESS_ONCE(*mc_running));
>> +
>> + /* Synchronise NIC with single word of time only */
>> + host_time = (now.tv_sec << MC_NANOSECOND_BITS) | now.tv_nsec;
>> + /* Update host time in NIC memory */
>> + _efx_writed(efx, host_time,
>> + FR_CZ_MC_TREG_SMEM + MC_SMEM_P0_PTP_TIME_OFST);
>> + }
>> + *last_time = now;
>> + start = timespec_sub(now, start);
>> +}
>> +
>> +/* Read a timeset from the MC's results and partial process. */
>> +static void efx_ptp_read_timeset(u8 *data, struct efx_ptp_timeset *timeset)
>> +{
>> + unsigned start_ns, end_ns;
>> +
>> + timeset->host_start = MCDI_DWORD(data, PTP_OUT_SYNCHRONIZE_HOSTSTART);
>> + timeset->seconds = MCDI_DWORD(data, PTP_OUT_SYNCHRONIZE_SECONDS);
>> + timeset->nanoseconds = MCDI_DWORD(data,
>> + PTP_OUT_SYNCHRONIZE_NANOSECONDS);
>> + timeset->host_end = MCDI_DWORD(data, PTP_OUT_SYNCHRONIZE_HOSTEND),
>> + timeset->waitns = MCDI_DWORD(data, PTP_OUT_SYNCHRONIZE_WAITNS);
>> +
>> + /* Ignore seconds */
>> + start_ns = timeset->host_start & MC_NANOSECOND_MASK;
>> + end_ns = timeset->host_end & MC_NANOSECOND_MASK;
>> + /* Allow for rollover */
>> + if (end_ns < start_ns)
>> + end_ns += NSEC_PER_SEC;
>> + /* Determine duration of operation */
>> + timeset->window = end_ns - start_ns;
>> +}
>> +
>> +/* Process times received from MC.
>> + *
>> + * Extract times from returned results, and establish the minimum value
>> + * seen. The minimum value represents the "best" possible time and events
>> + * too much greater than this are rejected - the machine is, perhaps, too
>> + * busy. A number of readings are taken so that, hopefully, at least one good
>> + * synchronisation will be seen in the results.
>> + */
>
> This code looks like it is trying to find the offset between two
> clocks. Is there some reason why you cannot use <linux/timecompare.h>
> to accomplish this?
This is what the code is doing. <linux/timecompare.h> states
"the assumption is that reading the source
time is slow and involves equal time for sending the request and
receiving the reply"
While in our case event though it is slow we cannot guarantee the second
assumption. The code above takes into account some of the particulars of the sfc
hardware and gives us good results.
>
> Also, these comments about "hopefull" synchronization make me
> nervous. I think it might be easier just to offer RAW timestamps and
> forget about the SYS timestamps.
This comment is perhaps a bit flippant and makes the situation sound
worse than it is.
>
> I am trying to purge the whole SYS thing (only blackfin is left)
> because there is a much better way to go about this, namely
> synchronizing the system time to the PHC time via an internal PPS
> signal.
This may be possible in future. But leads us to another problem
where the PPS event that is generated by the PHC subsystem to the
PPS subsystem is stamped with the current system_time. That may
be fine for a PPS signal generated from an interrupt but not when
the internal PPS event has implicit jitter from the handler/event_queue
that we have in the driver.
Calling pps_event directly does not seem possible with the current
header/structure layout preventing access to ptp_clock->pps_source.
Including ptp_private.h seems wrong.
>
>> +static int efx_ptp_process_times(struct efx_nic *efx, u8 *synch_buf,
>> + size_t response_length,
>> + struct timespec *last_time)
>> +{
>> + unsigned number_readings = (response_length /
>> + MC_CMD_PTP_OUT_SYNCHRONIZE_TIMESET_LEN);
>> + unsigned i;
>> + unsigned min;
>> + unsigned min_set = 0;
>> + unsigned total;
>> + unsigned ngood = 0;
>> + unsigned last_good = 0;
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + bool min_valid = false;
>> + u32 last_sec;
>> + u32 start_sec;
>> +
>> + if (number_readings == 0)
>> + return -EAGAIN;
>> +
>> + /* Find minimum value in this set of results, discarding clearly
>> + * erroneous results.
>> + */
>> + for (i = 0; i < number_readings; i++) {
>> + efx_ptp_read_timeset(synch_buf, &ptp->timeset[i]);
>> + synch_buf += MC_CMD_PTP_OUT_SYNCHRONIZE_TIMESET_LEN;
>> + if (ptp->timeset[i].window > SYNCHRONISATION_GRANULARITY_NS) {
>> + if (min_valid) {
>> + if (ptp->timeset[i].window < min_set)
>> + min_set = ptp->timeset[i].window;
>> + } else {
>> + min_valid = true;
>> + min_set = ptp->timeset[i].window;
>> + }
>> + }
>> + }
>> +
>> + if (min_valid) {
>> + if (ptp->base_sync_valid && (min_set > ptp->base_sync_ns))
>> + min = ptp->base_sync_ns;
>> + else
>> + min = min_set;
>> + } else {
>> + min = SYNCHRONISATION_GRANULARITY_NS;
>> + }
>> +
>> + /* Discard excessively long synchronise durations. The MC times
>> + * when it finishes reading the host time so the corrected window
>> + * time should be fairly constant for a given platform.
>> + */
>> + total = 0;
>> + for (i = 0; i < number_readings; i++)
>> + if (ptp->timeset[i].window > ptp->timeset[i].waitns) {
>> + unsigned win;
>> +
>> + win = ptp->timeset[i].window - ptp->timeset[i].waitns;
>> + if (win >= MIN_SYNCHRONISATION_NS &&
>> + win < MAX_SYNCHRONISATION_NS) {
>> + total += ptp->timeset[i].window;
>> + ngood++;
>> + last_good = i;
>> + }
>> + }
>> +
>> + if (ngood == 0) {
>> + netif_warn(efx, drv, efx->net_dev,
>> + "PTP no suitable synchronisations %dns %dns\n",
>> + ptp->base_sync_ns, min_set);
>> + return -EAGAIN;
>> + }
>> +
>> + /* Average minimum this synchronisation */
>> + ptp->last_sync_ns = DIV_ROUND_UP(total, ngood);
>> + if (!ptp->base_sync_valid || (ptp->last_sync_ns < ptp->base_sync_ns)) {
>> + ptp->base_sync_valid = true;
>> + ptp->base_sync_ns = ptp->last_sync_ns;
>> + }
>> +
>> + ptp->mc_base_time = ktime_set(ptp->timeset[last_good].seconds,
>> + ptp->timeset[last_good].nanoseconds);
>> + last_time->tv_nsec =
>> + ptp->timeset[last_good].host_start & MC_NANOSECOND_MASK;
>> +
>> + /* It is possible that the seconds rolled over between taking
>> + * the start reading and the last value written by the host. The
>> + * timescales are such that a gap of more than one second is never
>> + * expected.
>> + */
>> + start_sec = ptp->timeset[last_good].host_start >> MC_NANOSECOND_BITS;
>> + last_sec = last_time->tv_sec & MC_SECOND_MASK;
>> + if (start_sec != last_sec) {
>> + if (((start_sec + 1) & MC_SECOND_MASK) != last_sec) {
>> + netif_warn(efx, hw, efx->net_dev,
>> + "PTP bad synchronisation seconds\n");
>> + return -EAGAIN;
>> + } else {
>> + last_time->tv_sec--;
>> + }
>> + }
>> + ptp->host_base_time = ktime_set(last_time->tv_sec,
>> + last_time->tv_nsec);
>> +
>> + /* At least one good synchronisation */
>> + ptp->base_time_valid = true;
>> +
>> + return 0;
>> +}
>> +
>> +/* Synchronize times between the host and the MC */
>> +static int efx_ptp_synchronize(struct efx_nic *efx, unsigned int num_readings)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + u8 synch_buf[MC_CMD_PTP_OUT_SYNCHRONIZE_LENMAX];
>> + size_t response_length;
>> + int rc;
>> + unsigned long timeout;
>> + struct timespec last_time;
>> + unsigned int loops = 0;
>> + int *start = ptp->start.addr;
>> +
>> + last_time.tv_sec = 0;
>> + last_time.tv_nsec = 0;
>> +
>> + MCDI_SET_DWORD(synch_buf, PTP_IN_OP, MC_CMD_PTP_OP_SYNCHRONIZE);
>> + MCDI_SET_DWORD(synch_buf, PTP_IN_SYNCHRONIZE_NUMTIMESETS,
>> + num_readings);
>> + MCDI_SET_DWORD(synch_buf, PTP_IN_SYNCHRONIZE_START_ADDR_LO,
>> + (u32)ptp->start.dma_addr);
>> + MCDI_SET_DWORD(synch_buf, PTP_IN_SYNCHRONIZE_START_ADDR_HI,
>> + (u32)((u64)ptp->start.dma_addr >> 32));
>> +
>> + /* Clear flag that signals MC ready */
>> + ACCESS_ONCE(*start) = 0;
>> + efx_mcdi_rpc_start(efx, MC_CMD_PTP, synch_buf,
>> + MC_CMD_PTP_IN_SYNCHRONIZE_LEN);
>> +
>> + /* Wait for start from MCDI (or timeout) */
>> + timeout = jiffies + msecs_to_jiffies(MAX_SYNCHRONISE_WAIT_MS);
>> + while (!ACCESS_ONCE(*start) && (time_before(jiffies, timeout))) {
>> + udelay(20); /* Usually start MCDI execution quickly */
>> + loops++;
>> + }
>> +
>> + if (ACCESS_ONCE(*start))
>> + efx_ptp_send_times(efx, &last_time);
>> +
>> + /* Collect results */
>> + rc = efx_mcdi_rpc_finish(efx, MC_CMD_PTP,
>> + MC_CMD_PTP_IN_SYNCHRONIZE_LEN,
>> + synch_buf, sizeof(synch_buf),
>> + &response_length);
>> + if (rc == 0)
>> + rc = efx_ptp_process_times(efx, synch_buf, response_length,
>> + &last_time);
>> +
>> + return rc;
>> +}
>> +
>> +/* Get the host time from a given hardware time */
>> +static bool efx_ptp_get_host_time(struct efx_nic *efx,
>> + struct skb_shared_hwtstamps *timestamps)
>> +{
>> + if (efx->ptp_data->base_time_valid) {
>> + ktime_t diff = ktime_sub(timestamps->hwtstamp,
>> + efx->ptp_data->mc_base_time);
>> +
>> + timestamps->syststamp = ktime_add(efx->ptp_data->host_base_time,
>> + diff);
>> + }
>> +
>> + return efx->ptp_data->base_time_valid;
>> +}
>> +
>> +/* Transmit a PTP packet, via the MCDI interface, to the wire. */
>> +static int efx_ptp_xmit_skb(struct efx_nic *efx, struct sk_buff *skb)
>> +{
>> + u8 *txbuf = efx->ptp_data->txbuf;
>> + struct skb_shared_hwtstamps timestamps;
>> + int rc = -EIO;
>> + /* MCDI driver requires word aligned lengths */
>> + size_t len = ALIGN(MC_CMD_PTP_IN_TRANSMIT_LEN(skb->len), 4);
>> + u8 txtime[MC_CMD_PTP_OUT_TRANSMIT_LEN];
>> +
>> + MCDI_SET_DWORD(txbuf, PTP_IN_OP, MC_CMD_PTP_OP_TRANSMIT);
>> + MCDI_SET_DWORD(txbuf, PTP_IN_TRANSMIT_LENGTH, skb->len);
>> + if (skb_shinfo(skb)->nr_frags != 0) {
>> + rc = skb_linearize(skb);
>> + if (rc != 0)
>> + goto fail;
>> + }
>> +
>> + if (skb->ip_summed == CHECKSUM_PARTIAL) {
>> + rc = skb_checksum_help(skb);
>> + if (rc != 0)
>> + goto fail;
>> + }
>> + skb_copy_from_linear_data(skb,
>> + &txbuf[MC_CMD_PTP_IN_TRANSMIT_PACKET_OFST],
>> + len);
>> + rc = efx_mcdi_rpc(efx, MC_CMD_PTP, txbuf, len, txtime,
>> + sizeof(txtime), &len);
>> + if (rc != 0)
>> + goto fail;
>> +
>> + memset(×tamps, 0, sizeof(timestamps));
>> + timestamps.hwtstamp = ktime_set(
>> + MCDI_DWORD(txtime, PTP_OUT_TRANSMIT_SECONDS),
>> + MCDI_DWORD(txtime, PTP_OUT_TRANSMIT_NANOSECONDS));
>> + if (efx_ptp_get_host_time(efx, ×tamps))
>> + skb_tstamp_tx(skb, ×tamps);
>> + /* Success even if hardware timestamping failed */
>> + rc = 0;
>> +
>> +fail:
>> + dev_kfree_skb(skb);
>> +
>> + return rc;
>> +}
>> +
>> +static void efx_ptp_drop_time_expired_events(struct efx_nic *efx)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + struct list_head *cursor;
>> + struct list_head *next;
>> +
>> + /* Drop time-expired events */
>> + spin_lock_bh(&ptp->evt_lock);
>> + if (!list_empty(&ptp->evt_list)) {
>> + list_for_each_safe(cursor, next, &ptp->evt_list) {
>> + struct efx_ptp_event_rx *evt;
>> +
>> + evt = list_entry(cursor, struct efx_ptp_event_rx,
>> + link);
>> + if (time_after(jiffies, evt->expiry)) {
>> + list_del(&evt->link);
>> + list_add(&evt->link, &ptp->evt_free_list);
>> + netif_warn(efx, hw, efx->net_dev,
>> + "PTP rx event dropped\n");
>> + }
>> + }
>> + }
>> + spin_unlock_bh(&ptp->evt_lock);
>> +}
>> +
>> +static enum ptp_packet_state efx_ptp_match_rx(struct efx_nic *efx,
>> + struct sk_buff *skb)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + bool evts_waiting;
>> + struct list_head *cursor;
>> + struct list_head *next;
>> + struct efx_ptp_match *match;
>> + enum ptp_packet_state rc = PTP_PACKET_STATE_UNMATCHED;
>> +
>> + spin_lock_bh(&ptp->evt_lock);
>> + evts_waiting = !list_empty(&ptp->evt_list);
>> + spin_unlock_bh(&ptp->evt_lock);
>> +
>> + if (!evts_waiting)
>> + return PTP_PACKET_STATE_UNMATCHED;
>> +
>> + match = (struct efx_ptp_match *)skb->cb;
>> + /* Look for a matching timestamp in the event queue */
>> + spin_lock_bh(&ptp->evt_lock);
>> + list_for_each_safe(cursor, next, &ptp->evt_list) {
>> + struct efx_ptp_event_rx *evt;
>> +
>> + evt = list_entry(cursor, struct efx_ptp_event_rx, link);
>> + if ((evt->seq0 == match->words[0]) &&
>> + (evt->seq1 == match->words[1])) {
>> + struct skb_shared_hwtstamps *timestamps;
>> +
>> + /* Match - add in hardware timestamp */
>> + timestamps = skb_hwtstamps(skb);
>> + timestamps->hwtstamp = evt->hwtimestamp;
>> +
>> + match->state = PTP_PACKET_STATE_MATCHED;
>> + rc = PTP_PACKET_STATE_MATCHED;
>> + list_del(&evt->link);
>> + list_add(&evt->link, &ptp->evt_free_list);
>> + break;
>> + }
>> + }
>> + spin_unlock_bh(&ptp->evt_lock);
>> +
>> + return rc;
>> +}
>> +
>> +/* Process any queued receive events and corresponding packets
>> + *
>> + * q is returned with all the packets that are ready for delivery.
>> + * true is returned if at least one of those packets requires
>> + * synchronisation.
>> + */
>> +static bool efx_ptp_process_events(struct efx_nic *efx, struct sk_buff_head *q)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + bool rc = false;
>> + struct sk_buff *skb;
>> +
>> + while ((skb = skb_dequeue(&ptp->rxq))) {
>> + struct efx_ptp_match *match;
>> +
>> + match = (struct efx_ptp_match *)skb->cb;
>> + if (match->state == PTP_PACKET_STATE_MATCH_UNWANTED) {
>> + __skb_queue_tail(q, skb);
>> + } else if (efx_ptp_match_rx(efx, skb) ==
>> + PTP_PACKET_STATE_MATCHED) {
>> + rc = true;
>> + __skb_queue_tail(q, skb);
>> + } else if (time_after(jiffies, match->expiry)) {
>> + match->state = PTP_PACKET_STATE_TIMED_OUT;
>> + netif_warn(efx, rx_err, efx->net_dev,
>> + "PTP packet - no timestamp seen\n");
>> + __skb_queue_tail(q, skb);
>> + } else {
>> + /* Replace unprocessed entry and stop */
>> + skb_queue_head(&ptp->rxq, skb);
>> + break;
>> + }
>> + }
>> +
>> + return rc;
>> +}
>> +
>> +/* Complete processing of a received packet */
>> +static void efx_ptp_process_rx(struct efx_nic *efx, struct sk_buff *skb)
>> +{
>> + struct efx_ptp_match *match = (struct efx_ptp_match *)skb->cb;
>> +
>> + /* Translate timestamps, as required */
>> + if (match->state == PTP_PACKET_STATE_MATCHED) {
>> + struct skb_shared_hwtstamps *timestamps;
>> +
>> + timestamps = skb_hwtstamps(skb);
>> + efx_ptp_get_host_time(efx, timestamps);
>> + }
>> +
>> + local_bh_disable();
>> + netif_receive_skb(skb);
>> + local_bh_enable();
>> +}
>> +
>> +static int efx_ptp_start(struct efx_nic *efx)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + struct efx_filter_spec rxfilter;
>> + int rc;
>> +
>> + ptp->reset_required = false;
>> +
>> + /* Must resynchronise when starting */
>> + ptp->base_time_valid = false;
>> + ptp->base_sync_valid = false;
>> +
>> + /* Must filter on both event and general ports to ensure
>> + * that there is no packet re-ordering.
>> + */
>> + efx_filter_init_rx(&rxfilter, EFX_FILTER_PRI_REQUIRED, 0,
>> + efx_rx_queue_index(
>> + efx_channel_get_rx_queue(ptp->channel)));
>> + rc = efx_filter_set_ipv4_local(&rxfilter, IPPROTO_UDP,
>> + htonl(PTP_ADDRESS),
>> + htons(PTP_EVENT_PORT));
>> + if (rc != 0)
>> + return rc;
>> +
>> + rc = efx_filter_insert_filter(efx, &rxfilter, true);
>> + if (rc < 0)
>> + return rc;
>> + ptp->rxfilter_event = rc;
>> +
>> + efx_filter_init_rx(&rxfilter, EFX_FILTER_PRI_REQUIRED, 0,
>> + efx_rx_queue_index(
>> + efx_channel_get_rx_queue(ptp->channel)));
>> + rc = efx_filter_set_ipv4_local(&rxfilter, IPPROTO_UDP,
>> + htonl(PTP_ADDRESS),
>> + htons(PTP_GENERAL_PORT));
>> + if (rc != 0)
>> + goto fail;
>> +
>> + rc = efx_filter_insert_filter(efx, &rxfilter, true);
>> + if (rc < 0)
>> + goto fail;
>> + ptp->rxfilter_general = rc;
>> +
>> + rc = efx_ptp_enable(efx);
>> + if (rc != 0)
>> + goto fail2;
>> +
>> + ptp->evt_frag_idx = 0;
>> + ptp->current_adjfreq = 0;
>> + ptp->rxfilter_installed = true;
>> +
>> + return 0;
>> +
>> +fail2:
>> + efx_filter_remove_id_safe(efx, EFX_FILTER_PRI_REQUIRED,
>> + ptp->rxfilter_general);
>> +fail:
>> + efx_filter_remove_id_safe(efx, EFX_FILTER_PRI_REQUIRED,
>> + ptp->rxfilter_event);
>> +
>> + return rc;
>> +}
>> +
>> +static int efx_ptp_stop(struct efx_nic *efx)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + int rc = efx_ptp_disable(efx);
>> + struct list_head *cursor;
>> + struct list_head *next;
>> +
>> + if (ptp->rxfilter_installed) {
>> + efx_filter_remove_id_safe(efx, EFX_FILTER_PRI_REQUIRED,
>> + ptp->rxfilter_general);
>> + efx_filter_remove_id_safe(efx, EFX_FILTER_PRI_REQUIRED,
>> + ptp->rxfilter_event);
>> + ptp->rxfilter_installed = false;
>> + }
>> +
>> + /* Make sure RX packets are really delivered */
>> + efx_ptp_deliver_rx_queue(&efx->ptp_data->rxq);
>> + skb_queue_purge(&efx->ptp_data->txq);
>> +
>> + /* Drop any pending receive events */
>> + spin_lock_bh(&efx->ptp_data->evt_lock);
>> + list_for_each_safe(cursor, next, &efx->ptp_data->evt_list) {
>> + list_del(cursor);
>> + list_add(cursor, &efx->ptp_data->evt_free_list);
>> + }
>> + spin_unlock_bh(&efx->ptp_data->evt_lock);
>> +
>> + return rc;
>> +}
>> +
>> +static void efx_ptp_pps_worker(struct work_struct *work)
>> +{
>> + struct efx_ptp_data *ptp =
>> + container_of(work, struct efx_ptp_data, pps_work);
>> + struct efx_nic *efx = ptp->channel->efx;
>> + struct timespec event_gen_time;
>> + struct ptp_clock_event ptp_pps_evt;
>> + ktime_t gen_time_host;
>> +
>> + if (efx_ptp_synchronize(efx, PTP_SYNC_ATTEMPTS))
>> + return;
>> +
>> + gen_time_host = ktime_sub(ptp->mc_base_time,
>> + ptp->host_base_time);
>> + event_gen_time = ktime_to_timespec(gen_time_host);
>> +
>> + ptp_pps_evt.type = PTP_CLOCK_EXTTS;
>> + ptp_pps_evt.timestamp = ktime_to_ns(gen_time_host);
>> + ptp_clock_event(ptp->phc_clock, &ptp_pps_evt);
>> +}
>> +
>> +/* Process any pending transmissions and timestamp any received packets.
>> + *
>> + * Host and NIC time are synchronised once if there is any work to do:
>> + * the process is relatively expensive so don't do it for each packet.
>> + */
>> +static void efx_ptp_worker(struct work_struct *work)
>> +{
>> + struct efx_ptp_data *ptp_data =
>> + container_of(work, struct efx_ptp_data, work);
>> + struct efx_nic *efx = ptp_data->channel->efx;
>> + struct sk_buff *skb;
>> + struct sk_buff_head tempq;
>> +
>> + if (ptp_data->reset_required) {
>> + efx_ptp_stop(efx);
>> + efx_ptp_start(efx);
>> + return;
>> + }
>> +
>> + efx_ptp_drop_time_expired_events(efx);
>> +
>> + __skb_queue_head_init(&tempq);
>> + if (efx_ptp_process_events(efx, &tempq) ||
>> + !skb_queue_empty(&ptp_data->txq)) {
>> + /* Synchronise PC/MC times when there's work to do. This
>> + * isn't fatal but would be unusual (because of the retries
>> + * within efx_ptp_synchronize). Failure may suggest a heavily
>> + * overloaded system.
>> + */
>> + if (0 != efx_ptp_synchronize(efx, PTP_SYNC_ATTEMPTS))
>> + netif_warn(efx, drv, efx->net_dev,
>> + "PTP couldn't get synchronisation\n");
>> +
>> + while ((skb = skb_dequeue(&ptp_data->txq)))
>> + efx_ptp_xmit_skb(efx, skb);
>> + }
>> +
>> + while ((skb = __skb_dequeue(&tempq)))
>> + efx_ptp_process_rx(efx, skb);
>> +}
>> +
>> +/* Initialise PTP channel and state.
>> + *
>> + * Setting core_index to zero causes the queue to be initialised and doesn't
>> + * overlap with 'rxq0' because ptp.c doesn't use skb_record_rx_queue.
>> + */
>> +static int efx_ptp_probe_channel(struct efx_channel *channel)
>> +{
>> + struct efx_nic *efx = channel->efx;
>> + struct efx_ptp_data *ptp;
>> + int rc = 0;
>> + unsigned int pos;
>> +
>> + channel->irq_moderation = 0;
>> + channel->rx_queue.core_index = 0;
>> +
>> + ptp = kzalloc(sizeof(struct efx_ptp_data), GFP_KERNEL);
>> + efx->ptp_data = ptp;
>> + if (!efx->ptp_data)
>> + return -ENOMEM;
>> +
>> + rc = efx_nic_alloc_buffer(efx, &ptp->start, sizeof(int));
>> + if (rc != 0)
>> + goto fail1;
>> +
>> + ptp->channel = channel;
>> + skb_queue_head_init(&ptp->rxq);
>> + skb_queue_head_init(&ptp->txq);
>> + ptp->workwq = create_singlethread_workqueue("sfc_ptp");
>> + if (!ptp->workwq) {
>> + rc = -ENOMEM;
>> + goto fail2;
>> + }
>> +
>> + INIT_WORK(&ptp->work, efx_ptp_worker);
>> + ptp->config.flags = 0;
>> + ptp->config.tx_type = HWTSTAMP_TX_OFF;
>> + ptp->config.rx_filter = HWTSTAMP_FILTER_NONE;
>> + INIT_LIST_HEAD(&ptp->evt_list);
>> + INIT_LIST_HEAD(&ptp->evt_free_list);
>> + spin_lock_init(&ptp->evt_lock);
>> + for (pos = 0; pos < MAX_RECEIVE_EVENTS; pos++)
>> + list_add(&ptp->rx_evts[pos].link, &ptp->evt_free_list);
>> +
>> + ptp->phc_clock_info.owner = THIS_MODULE;
>> + snprintf(ptp->phc_clock_info.name,
>> + sizeof(ptp->phc_clock_info.name),
>> + "%pm", efx->net_dev->perm_addr);
>> + ptp->phc_clock_info.max_adj = MAX_PPB;
>> + ptp->phc_clock_info.n_alarm = 0;
>> + ptp->phc_clock_info.n_ext_ts = 1;
>> + ptp->phc_clock_info.n_per_out = 0;
>> + ptp->phc_clock_info.pps = 0;
>> + ptp->phc_clock_info.adjfreq = efx_phc_adjfreq;
>> + ptp->phc_clock_info.adjtime = efx_phc_adjtime;
>> + ptp->phc_clock_info.gettime = efx_phc_gettime;
>> + ptp->phc_clock_info.settime = efx_phc_settime;
>> + ptp->phc_clock_info.enable = efx_phc_enable;
>> +
>> + ptp->phc_clock = ptp_clock_register(&ptp->phc_clock_info);
>> + if (!ptp->phc_clock)
>> + goto fail3;
>> +
>> + INIT_WORK(&ptp->pps_work, efx_ptp_pps_worker);
>> + ptp->pps_workwq = create_singlethread_workqueue("sfc_pps");
>> + if (!ptp->pps_workwq) {
>> + rc = -ENOMEM;
>> + goto fail4;
>> + }
>> + ptp->nic_ts_enabled = false;
>> +
>> + return 0;
>> +fail4:
>> + ptp_clock_unregister(efx->ptp_data->phc_clock);
>> +
>> +fail3:
>> + destroy_workqueue(efx->ptp_data->workwq);
>> +
>> +fail2:
>> + efx_nic_free_buffer(efx, &ptp->start);
>> +
>> +fail1:
>> + kfree(efx->ptp_data);
>> + efx->ptp_data = 0;
>> +
>> + return rc;
>> +}
>> +
>> +static void efx_ptp_remove_channel(struct efx_channel *channel)
>> +{
>> + struct efx_nic *efx = channel->efx;
>> +
>> + if (!efx->ptp_data)
>> + return;
>> +
>> + (void)efx_ptp_disable(channel->efx);
>> +
>> + cancel_work_sync(&efx->ptp_data->work);
>> + cancel_work_sync(&efx->ptp_data->pps_work);
>> +
>> + skb_queue_purge(&efx->ptp_data->rxq);
>> + skb_queue_purge(&efx->ptp_data->txq);
>> +
>> + ptp_clock_unregister(efx->ptp_data->phc_clock);
>> +
>> + destroy_workqueue(efx->ptp_data->workwq);
>> + destroy_workqueue(efx->ptp_data->pps_workwq);
>> +
>> + efx_nic_free_buffer(efx, &efx->ptp_data->start);
>> + kfree(efx->ptp_data);
>> +}
>> +
>> +static void efx_ptp_get_channel_name(struct efx_channel *channel,
>> + char *buf, size_t len)
>> +{
>> + snprintf(buf, len, "%s-ptp", channel->efx->name);
>> +}
>> +
>> +/* Determine whether this packet should be processed by the PTP module
>> + * or transmitted conventionally.
>> + */
>> +bool efx_ptp_is_ptp_tx(struct efx_nic *efx, struct sk_buff *skb)
>> +{
>> + return efx->ptp_data &&
>> + efx->ptp_data->enabled &&
>> + skb->len >= PTP_MIN_LENGTH &&
>> + skb->len <= MC_CMD_PTP_IN_TRANSMIT_PACKET_MAXNUM &&
>> + likely(skb->protocol == htons(ETH_P_IP)) &&
>> + ip_hdr(skb)->protocol == IPPROTO_UDP &&
>> + udp_hdr(skb)->dest == htons(PTP_EVENT_PORT);
>> +}
>> +
>> +/* Receive a PTP packet. Packets are queued until the arrival of
>> + * the receive timestamp from the MC - this will probably occur after the
>> + * packet arrival because of the processing in the MC.
>> + */
>> +static void efx_ptp_rx(struct efx_channel *channel, struct sk_buff *skb)
>> +{
>> + struct efx_nic *efx = channel->efx;
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + struct efx_ptp_match *match = (struct efx_ptp_match *)skb->cb;
>> + u8 *data;
>> + unsigned int version;
>> +
>> + match->expiry = jiffies + msecs_to_jiffies(PKT_EVENT_LIFETIME_MS);
>> +
>> + /* Correct version? */
>> + if (ptp->mode == MC_CMD_PTP_MODE_V1) {
>> + if (skb->len < PTP_V1_MIN_LENGTH) {
>> + netif_receive_skb(skb);
>> + return;
>> + }
>> + version = ntohs(*(__be16 *)&skb->data[PTP_V1_VERSION_OFFSET]);
>> + if (version != PTP_VERSION_V1) {
>> + netif_receive_skb(skb);
>> + return;
>> + }
>> + } else {
>> + if (skb->len < PTP_V2_MIN_LENGTH) {
>> + netif_receive_skb(skb);
>> + return;
>> + }
>> + version = skb->data[PTP_V2_VERSION_OFFSET];
>> +
>> + BUG_ON(ptp->mode != MC_CMD_PTP_MODE_V2);
>> + BUILD_BUG_ON(PTP_V1_UUID_OFFSET != PTP_V2_MC_UUID_OFFSET);
>> + BUILD_BUG_ON(PTP_V1_UUID_LENGTH != PTP_V2_MC_UUID_LENGTH);
>> + BUILD_BUG_ON(PTP_V1_SEQUENCE_OFFSET != PTP_V2_SEQUENCE_OFFSET);
>> + BUILD_BUG_ON(PTP_V1_SEQUENCE_LENGTH != PTP_V2_SEQUENCE_LENGTH);
>> +
>> + if ((version & PTP_VERSION_V2_MASK) != PTP_VERSION_V2) {
>> + netif_receive_skb(skb);
>> + return;
>> + }
>> + }
>> +
>> + /* Does this packet require timestamping? */
>> + if (ntohs(*(__be16 *)&skb->data[PTP_DPORT_OFFSET]) == PTP_EVENT_PORT) {
>> + struct skb_shared_hwtstamps *timestamps;
>> +
>> + match->state = PTP_PACKET_STATE_UNMATCHED;
>> +
>> + /* Clear all timestamps held: filled in later */
>> + timestamps = skb_hwtstamps(skb);
>> + memset(timestamps, 0, sizeof(*timestamps));
>> +
>> + /* Extract UUID/Sequence information */
>> + data = skb->data + PTP_V1_UUID_OFFSET;
>> + match->words[0] = (data[0] |
>> + (data[1] << 8) |
>> + (data[2] << 16) |
>> + (data[3] << 24));
>> + match->words[1] = (data[4] |
>> + (data[5] << 8) |
>> + (skb->data[PTP_V1_SEQUENCE_OFFSET +
>> + PTP_V1_SEQUENCE_LENGTH - 1] <<
>> + 16));
>> + } else {
>> + match->state = PTP_PACKET_STATE_MATCH_UNWANTED;
>> + }
>> +
>> + skb_queue_tail(&ptp->rxq, skb);
>> + queue_work(ptp->workwq, &ptp->work);
>> +}
>> +
>> +/* Transmit a PTP packet. This has to be transmitted by the MC
>> + * itself, through an MCDI call. MCDI calls aren't permitted
>> + * in the transmit path so defer the actual transmission to a suitable worker.
>> + */
>> +int efx_ptp_tx(struct efx_nic *efx, struct sk_buff *skb)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> +
>> + skb_queue_tail(&ptp->txq, skb);
>> +
>> + if ((udp_hdr(skb)->dest == htons(PTP_EVENT_PORT)) &&
>> + (skb->len <= MC_CMD_PTP_IN_TRANSMIT_PACKET_MAXNUM))
>> + efx_xmit_hwtstamp_pending(skb);
>> + queue_work(ptp->workwq, &ptp->work);
>> +
>> + return NETDEV_TX_OK;
>> +}
>> +
>> +static int efx_ptp_change_mode(struct efx_nic *efx, bool enable_wanted,
>> + unsigned int new_mode)
>> +{
>> + if ((enable_wanted != efx->ptp_data->enabled) ||
>> + (enable_wanted && (efx->ptp_data->mode != new_mode))) {
>> + int rc;
>> +
>> + if (enable_wanted) {
>> + /* Change of mode requires disable */
>> + if (efx->ptp_data->enabled &&
>> + (efx->ptp_data->mode != new_mode)) {
>> + efx->ptp_data->enabled = false;
>> + rc = efx_ptp_stop(efx);
>> + if (rc != 0)
>> + return rc;
>> + }
>> +
>> + /* Set new operating mode and establish
>> + * baseline synchronisation, which must
>> + * succeed.
>> + */
>> + efx->ptp_data->mode = new_mode;
>> + rc = efx_ptp_start(efx);
>> + if (rc == 0) {
>> + rc = efx_ptp_synchronize(efx,
>> + PTP_SYNC_ATTEMPTS * 2);
>> + if (rc != 0)
>> + efx_ptp_stop(efx);
>> + }
>> + } else {
>> + rc = efx_ptp_stop(efx);
>> + }
>> +
>> + if (rc != 0)
>> + return rc;
>> +
>> + efx->ptp_data->enabled = enable_wanted;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static int efx_ptp_ts_init(struct efx_nic *efx, struct hwtstamp_config *init)
>> +{
>> + bool enable_wanted = false;
>> + unsigned int new_mode;
>> + int rc;
>> +
>> + if (init->flags)
>> + return -EINVAL;
>> +
>> + if ((init->tx_type != HWTSTAMP_TX_OFF) &&
>> + (init->tx_type != HWTSTAMP_TX_ON))
>> + return -ERANGE;
>> +
>> + new_mode = efx->ptp_data->mode;
>> + /* Determine whether any PTP HW operations are required */
>> + switch (init->rx_filter) {
>> + case HWTSTAMP_FILTER_NONE:
>> + break;
>> + case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
>> + case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
>> + case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
>> + init->rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_EVENT;
>> + new_mode = MC_CMD_PTP_MODE_V1;
>> + enable_wanted = true;
>> + break;
>> + case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
>> + case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
>> + case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
>> + /* Although these three are accepted only IPV4 packets will be
>> + * timestamped
>> + */
>> + case HWTSTAMP_FILTER_PTP_V2_EVENT:
>> + case HWTSTAMP_FILTER_PTP_V2_SYNC:
>> + case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
>> + init->rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_EVENT;
>> + new_mode = MC_CMD_PTP_MODE_V2;
>> + enable_wanted = true;
>> + break;
>> + case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
>> + case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
>> + case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
>> + /* Non-IP timestamping not supported */
>> + return -ERANGE;
>> + break;
>> + default:
>> + return -ERANGE;
>> + }
>> +
>> + if (init->tx_type != HWTSTAMP_TX_OFF)
>> + enable_wanted = true;
>> +
>> + rc = efx_ptp_change_mode(efx, enable_wanted, new_mode);
>> + if (rc != 0)
>> + return rc;
>> +
>> + efx->ptp_data->config = *init;
>> +
>> + return 0;
>> +}
>> +
>> +int
>> +efx_ptp_get_ts_info(struct net_device *net_dev, struct ethtool_ts_info *ts_info)
>> +{
>> + struct efx_nic *efx = netdev_priv(net_dev);
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> +
>> + if (!ptp)
>> + return -EOPNOTSUPP;
>> +
>> + ts_info->so_timestamping = (SOF_TIMESTAMPING_TX_HARDWARE |
>> + SOF_TIMESTAMPING_RX_HARDWARE |
>> + SOF_TIMESTAMPING_SYS_HARDWARE |
>> + SOF_TIMESTAMPING_RAW_HARDWARE);
>> + ts_info->phc_index = ptp_clock_index(ptp->phc_clock);
>> + ts_info->tx_types = 1 << HWTSTAMP_TX_OFF | 1 << HWTSTAMP_TX_ON;
>> + ts_info->rx_filters = (1 << HWTSTAMP_FILTER_NONE |
>> + 1 << HWTSTAMP_FILTER_PTP_V1_L4_EVENT |
>> + 1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC |
>> + 1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ |
>> + 1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT |
>> + 1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC |
>> + 1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ |
>> + 1 << HWTSTAMP_FILTER_PTP_V2_EVENT |
>> + 1 << HWTSTAMP_FILTER_PTP_V2_SYNC |
>> + 1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ);
>> + return 0;
>> +}
>> +
>> +int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd)
>> +{
>> + struct hwtstamp_config config;
>> + int rc;
>> +
>> + /* Not a PTP enabled port */
>> + if (!efx->ptp_data)
>> + return -EOPNOTSUPP;
>> +
>> + if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
>> + return -EFAULT;
>> +
>> + rc = efx_ptp_ts_init(efx, &config);
>> + if (rc != 0)
>> + return rc;
>> +
>> + return copy_to_user(ifr->ifr_data, &config, sizeof(config))
>> + ? -EFAULT : 0;
>> +}
>> +
>> +static void ptp_event_failure(struct efx_nic *efx, int expected_frag_len)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> +
>> + netif_err(efx, hw, efx->net_dev,
>> + "PTP unexpected event length: got %d expected %d\n",
>> + ptp->evt_frag_idx, expected_frag_len);
>> + ptp->reset_required = true;
>> + queue_work(ptp->workwq, &ptp->work);
>> +}
>> +
>> +/* Process a completed receive event. Put it on the event queue and
>> + * start worker thread. This is required because event and their
>> + * correspoding packets may come in either order.
>> + */
>> +static void ptp_event_rx(struct efx_nic *efx, struct efx_ptp_data *ptp)
>> +{
>> + struct efx_ptp_event_rx *evt = NULL;
>> +
>> + if (ptp->evt_frag_idx != 3) {
>> + ptp_event_failure(efx, 3);
>> + return;
>> + }
>> +
>> + spin_lock_bh(&ptp->evt_lock);
>> + if (!list_empty(&ptp->evt_free_list)) {
>> + evt = list_first_entry(&ptp->evt_free_list,
>> + struct efx_ptp_event_rx, link);
>> + list_del(&evt->link);
>> +
>> + evt->seq0 = EFX_QWORD_FIELD(ptp->evt_frags[2], MCDI_EVENT_DATA);
>> + evt->seq1 = (EFX_QWORD_FIELD(ptp->evt_frags[2],
>> + MCDI_EVENT_SRC) |
>> + (EFX_QWORD_FIELD(ptp->evt_frags[1],
>> + MCDI_EVENT_SRC) << 8) |
>> + (EFX_QWORD_FIELD(ptp->evt_frags[0],
>> + MCDI_EVENT_SRC) << 16));
>> + evt->hwtimestamp = ktime_set(
>> + EFX_QWORD_FIELD(ptp->evt_frags[0], MCDI_EVENT_DATA),
>> + EFX_QWORD_FIELD(ptp->evt_frags[1], MCDI_EVENT_DATA));
>> + evt->expiry = jiffies + msecs_to_jiffies(PKT_EVENT_LIFETIME_MS);
>> + list_add_tail(&evt->link, &ptp->evt_list);
>> +
>> + queue_work(ptp->workwq, &ptp->work);
>> + } else {
>> + netif_err(efx, rx_err, efx->net_dev, "No free PTP event");
>> + }
>> + spin_unlock_bh(&ptp->evt_lock);
>> +}
>> +
>> +static void ptp_event_fault(struct efx_nic *efx, struct efx_ptp_data *ptp)
>> +{
>> + int code = EFX_QWORD_FIELD(ptp->evt_frags[0], MCDI_EVENT_DATA);
>> + if (ptp->evt_frag_idx != 1) {
>> + ptp_event_failure(efx, 1);
>> + return;
>> + }
>> +
>> + netif_err(efx, hw, efx->net_dev, "PTP error %d\n", code);
>> +}
>> +
>> +static void ptp_event_pps(struct efx_nic *efx, struct efx_ptp_data *ptp)
>> +{
>> + if (ptp->nic_ts_enabled)
>> + queue_work(ptp->pps_workwq, &ptp->pps_work);
>> +}
>> +
>> +void efx_ptp_event(struct efx_nic *efx, efx_qword_t *ev)
>> +{
>> + struct efx_ptp_data *ptp = efx->ptp_data;
>> + int code = EFX_QWORD_FIELD(*ev, MCDI_EVENT_CODE);
>> +
>> + if (!ptp->enabled)
>> + return;
>> +
>> + if (ptp->evt_frag_idx == 0) {
>> + ptp->evt_code = code;
>> + } else if (ptp->evt_code != code) {
>> + netif_err(efx, hw, efx->net_dev,
>> + "PTP out of sequence event %d\n", code);
>> + ptp->evt_frag_idx = 0;
>> + }
>> +
>> + ptp->evt_frags[ptp->evt_frag_idx++] = *ev;
>> + if (!MCDI_EVENT_FIELD(*ev, CONT)) {
>> + /* Process resulting event */
>> + switch (code) {
>> + case MCDI_EVENT_CODE_PTP_RX:
>> + ptp_event_rx(efx, ptp);
>> + break;
>> + case MCDI_EVENT_CODE_PTP_FAULT:
>> + ptp_event_fault(efx, ptp);
>> + break;
>> + case MCDI_EVENT_CODE_PTP_PPS:
>> + ptp_event_pps(efx, ptp);
>> + break;
>> + default:
>> + netif_err(efx, hw, efx->net_dev,
>> + "PTP unknown event %d\n", code);
>> + break;
>> + }
>> + ptp->evt_frag_idx = 0;
>> + } else if (MAX_EVENT_FRAGS == ptp->evt_frag_idx) {
>> + netif_err(efx, hw, efx->net_dev,
>> + "PTP too many event fragments\n");
>> + ptp->evt_frag_idx = 0;
>> + }
>> +}
>> +
>> +static int efx_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta)
>> +{
>> + struct efx_ptp_data *ptp_data = container_of(ptp,
>> + struct efx_ptp_data,
>> + phc_clock_info);
>> + struct efx_nic *efx = ptp_data->channel->efx;
>> + u8 inadj[MC_CMD_PTP_IN_ADJUST_LEN];
>> + s64 adjustment_ns;
>> + int rc;
>> +
>> + if (delta > MAX_PPB)
>> + delta = MAX_PPB;
>> + else if (delta < -MAX_PPB)
>> + delta = -MAX_PPB;
>> +
>> + /* Convert ppb to fixed point ns. */
>> + adjustment_ns = (((s64)delta * PPB_SCALE_WORD) >>
>> + (PPB_EXTRA_BITS + MAX_PPB_BITS));
>> +
>> + MCDI_SET_DWORD(inadj, PTP_IN_OP, MC_CMD_PTP_OP_ADJUST);
>> + MCDI_SET_DWORD(inadj, PTP_IN_ADJUST_FREQ_LO, (u32)adjustment_ns);
>> + MCDI_SET_DWORD(inadj, PTP_IN_ADJUST_FREQ_HI,
>> + (u32)(adjustment_ns >> 32));
>> + MCDI_SET_DWORD(inadj, PTP_IN_ADJUST_SECONDS, 0);
>> + MCDI_SET_DWORD(inadj, PTP_IN_ADJUST_NANOSECONDS, 0);
>> + rc = efx_mcdi_rpc(efx, MC_CMD_PTP, inadj, sizeof(inadj),
>> + NULL, 0, NULL);
>> + if (rc != 0)
>> + return rc;
>> +
>> + ptp_data->current_adjfreq = delta;
>> + return 0;
>> +}
>> +
>> +static int efx_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)
>> +{
>> + struct efx_ptp_data *ptp_data = container_of(ptp,
>> + struct efx_ptp_data,
>> + phc_clock_info);
>> + struct efx_nic *efx = ptp_data->channel->efx;
>> + struct timespec delta_ts = ns_to_timespec(delta);
>> + u8 inbuf[MC_CMD_PTP_IN_ADJUST_LEN];
>> +
>> + MCDI_SET_DWORD(inbuf, PTP_IN_OP, MC_CMD_PTP_OP_ADJUST);
>> + MCDI_SET_DWORD(inbuf, PTP_IN_ADJUST_FREQ_LO, 0);
>> + MCDI_SET_DWORD(inbuf, PTP_IN_ADJUST_FREQ_HI, 0);
>> + MCDI_SET_DWORD(inbuf, PTP_IN_ADJUST_SECONDS, (u32)delta_ts.tv_sec);
>> + MCDI_SET_DWORD(inbuf, PTP_IN_ADJUST_NANOSECONDS, (u32)delta_ts.tv_nsec);
>> + return efx_mcdi_rpc(efx, MC_CMD_PTP, inbuf, sizeof(inbuf),
>> + NULL, 0, NULL);
>> +}
>> +
>> +static int efx_phc_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
>> +{
>> + struct efx_ptp_data *ptp_data = container_of(ptp,
>> + struct efx_ptp_data,
>> + phc_clock_info);
>> + struct efx_nic *efx = ptp_data->channel->efx;
>> + u8 inbuf[MC_CMD_PTP_IN_READ_NIC_TIME_LEN];
>> + u8 outbuf[MC_CMD_PTP_OUT_READ_NIC_TIME_LEN];
>> + int rc;
>> +
>> + MCDI_SET_DWORD(inbuf, PTP_IN_OP, MC_CMD_PTP_OP_READ_NIC_TIME);
>> +
>> + rc = efx_mcdi_rpc(efx, MC_CMD_PTP, inbuf, sizeof(inbuf),
>> + outbuf, sizeof(outbuf), NULL);
>> + if (rc != 0)
>> + return rc;
>> +
>> + ts->tv_sec = MCDI_DWORD(outbuf, PTP_OUT_READ_NIC_TIME_SECONDS);
>> + ts->tv_nsec = MCDI_DWORD(outbuf, PTP_OUT_READ_NIC_TIME_NANOSECONDS);
>> + return 0;
>> +}
>> +
>> +static int efx_phc_settime(struct ptp_clock_info *ptp,
>> + const struct timespec *e_ts)
>> +{
>> + /* We must provide this function, but we cannot actually set the time */
>
> Huh? You can adjtime, so must be able to settime, too, right?
>
> If you have enough range in the RAW timestamp in the MC firmware (like
> 64 bits of nanoseconds), and you allow settime, then you can spare the
> system time synchronization code altogether.
>
You will have to elaborate further on this point.
> Thanks,
> Richard
>
>
Stu
>> + return -EOPNOTSUPP;
>> +}
>> +
>> +static int efx_phc_enable(struct ptp_clock_info *ptp,
>> + struct ptp_clock_request *request,
>> + int enable)
>> +{
>> + struct efx_ptp_data *ptp_data = container_of(ptp,
>> + struct efx_ptp_data,
>> + phc_clock_info);
>> + if (request->type != PTP_CLK_REQ_EXTTS)
>> + return -EOPNOTSUPP;
>> +
>> + ptp_data->nic_ts_enabled = !!enable;
>> + return 0;
>> +}
>> +
>> +static const struct efx_channel_type efx_ptp_channel_type = {
>> + .handle_no_channel = efx_ptp_handle_no_channel,
>> + .pre_probe = efx_ptp_probe_channel,
>> + .post_remove = efx_ptp_remove_channel,
>> + .get_name = efx_ptp_get_channel_name,
>> + /* no copy operation; there is no need to reallocate this channel */
>> + .receive_skb = efx_ptp_rx,
>> + .keep_eventq = false,
>> +};
>> +
>> +void efx_ptp_probe(struct efx_nic *efx)
>> +{
>> + /* Check whether PTP is implemented on this NIC. The DISABLE
>> + * operation will succeed if and only if it is implemented.
>> + */
>> + if (efx_ptp_disable(efx) == 0)
>> + efx->extra_channel_type[EFX_EXTRA_CHANNEL_PTP] =
>> + &efx_ptp_channel_type;
>> +}
>> diff --git a/drivers/net/ethernet/sfc/rx.c b/drivers/net/ethernet/sfc/rx.c
>> index 92699a0..8923863 100644
>> --- a/drivers/net/ethernet/sfc/rx.c
>> +++ b/drivers/net/ethernet/sfc/rx.c
>> @@ -573,7 +573,7 @@ static void efx_rx_deliver(struct efx_channel *channel,
>> /* Record the rx_queue */
>> skb_record_rx_queue(skb, channel->rx_queue.core_index);
>>
>> - /* Does the channel want to handle the skb */
>> + /* Pass the packet up */
>> if (channel->type->receive_skb)
>> channel->type->receive_skb(channel, skb);
>> else
>> diff --git a/drivers/net/ethernet/sfc/siena.c b/drivers/net/ethernet/sfc/siena.c
>> index 6bafd21..84b41bf 100644
>> --- a/drivers/net/ethernet/sfc/siena.c
>> +++ b/drivers/net/ethernet/sfc/siena.c
>> @@ -335,6 +335,7 @@ static int siena_probe_nic(struct efx_nic *efx)
>> goto fail5;
>>
>> efx_sriov_probe(efx);
>> + efx_ptp_probe(efx);
>>
>> return 0;
>>
>> diff --git a/drivers/net/ethernet/sfc/tx.c b/drivers/net/ethernet/sfc/tx.c
>> index 9b225a7..66badf8 100644
>> --- a/drivers/net/ethernet/sfc/tx.c
>> +++ b/drivers/net/ethernet/sfc/tx.c
>> @@ -347,6 +347,12 @@ netdev_tx_t efx_hard_start_xmit(struct sk_buff *skb,
>>
>> EFX_WARN_ON_PARANOID(!netif_device_present(net_dev));
>>
>> + /* PTP "event" packet */
>> + if (unlikely(efx_xmit_with_hwtstamp(skb)) &&
>> + unlikely(efx_ptp_is_ptp_tx(efx, skb))) {
>> + return efx_ptp_tx(efx, skb);
>> + }
>> +
>> index = skb_get_queue_mapping(skb);
>> type = skb->ip_summed == CHECKSUM_PARTIAL ? EFX_TXQ_TYPE_OFFLOAD : 0;
>> if (index >= efx->n_tx_channels) {
>> --
>> 1.7.7.6
>>
>>
>>
>> --
>> Ben Hutchings, Staff Engineer, Solarflare
>> Not speaking for my employer; that's the marketing department's job.
>> They asked us to note that Solarflare product names are trademarked.
>>
> --
> To unsubscribe from this list: send the line "unsubscribe netdev" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH] Crash in tun
From: David Miller @ 2012-07-19 15:28 UTC (permalink / raw)
To: eric.dumazet; +Cc: mikulas, maxk, vtun, netdev
In-Reply-To: <1342678175.2626.3849.camel@edumazet-glaptop>
From: Eric Dumazet <eric.dumazet@gmail.com>
Date: Thu, 19 Jul 2012 08:09:35 +0200
> A fix for this problem is : http://patchwork.ozlabs.org/patch/170440/
But it was submitted as an RFC so much be resubmitted formally
as a non-RFC patch.
^ permalink raw reply
* Re: [net-next 0/9][pull request] Intel Wired LAN Driver Updates
From: David Miller @ 2012-07-19 15:26 UTC (permalink / raw)
To: jeffrey.t.kirsher; +Cc: netdev, gospo, sassmann
In-Reply-To: <1342643516-2696-1-git-send-email-jeffrey.t.kirsher@intel.com>
From: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Date: Wed, 18 Jul 2012 13:31:47 -0700
> This series contains updates to ixgbevf & ixgbe.
>
> The following are changes since commit ddbe503203855939946430e39bae58de11b70b69:
> ipv6: add ipv6_addr_hash() helper
> and are available in the git repository at:
> git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/net-next master
>
> Alexander Duyck (8):
> ixgbevf: Do not rewind the Rx ring before bumping tail
> ixgbevf: Add netdev to ring structure
> ixgbevf: Consolidate Tx context descriptor creation code
> ixgbevf: Fix multiple issues in ixgbevf_get/set_ringparam
> ixgbe: Update configure virtualization to allow for multiple PF pools
> ixgbe: Add support for SR-IOV w/ DCB or RSS
> ixgbe: Retire RSS enabled and capable flags
> ixgbe: Cleanup holes in flags after removing several of them
>
> Pascal Bouchareine (1):
> ixgbevf: fix VF untagging when 802.1 prio is set
Pulled, thanks Jeff.
^ permalink raw reply
* Re: [PATCH net-next 4/7] sfc: Add support for IEEE-1588 PTP
From: Ben Hutchings @ 2012-07-19 14:37 UTC (permalink / raw)
To: Richard Cochran, Andrew Jackson; +Cc: David Miller, netdev, linux-net-drivers
In-Reply-To: <20120719142558.GB24484@localhost.localdomain>
On Thu, 2012-07-19 at 16:25 +0200, Richard Cochran wrote:
> On Wed, Jul 18, 2012 at 07:21:33PM +0100, Ben Hutchings wrote:
> > Add PTP IEEE-1588 support and make accesible via the PHC subsystem.
> >
> > This work is based on prior code by Andrew Jackson
> >
> > Signed-off-by: Stuart Hodgson <smhodgson@solarflare.com>
> > Signed-off-by: Ben Hutchings <bhutchings@solarflare.com>
[...]
> > --- a/drivers/net/ethernet/sfc/nic.h
> > +++ b/drivers/net/ethernet/sfc/nic.h
> > @@ -250,6 +250,37 @@ extern int efx_sriov_get_vf_config(struct net_device *dev, int vf,
> > extern int efx_sriov_set_vf_spoofchk(struct net_device *net_dev, int vf,
> > bool spoofchk);
> >
> > +struct ethtool_ts_info;
> > +#ifdef CONFIG_SFC_PTP
> > +extern void efx_ptp_probe(struct efx_nic *efx);
> > +extern int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd);
> > +extern int efx_ptp_get_ts_info(struct net_device *net_dev,
> > + struct ethtool_ts_info *ts_info);
> > +extern bool efx_ptp_is_ptp_tx(struct efx_nic *efx, struct sk_buff *skb);
> > +extern int efx_ptp_tx(struct efx_nic *efx, struct sk_buff *skb);
> > +extern void efx_ptp_event(struct efx_nic *efx, efx_qword_t *ev);
> > +#else
> > +static inline void efx_ptp_probe(struct efx_nic *efx) {}
> > +static inline int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd)
> > +{
> > + return -EOPNOTSUPP;
> > +}
> > +static inline int efx_ptp_get_ts_info(struct net_device *net_dev,
> > + struct ethtool_ts_info *ts_info)
> > +{
> > + return -EOPNOTSUPP;
>
> If your PTP support is not enabled, then it would be better to offer
> the standard ethtool answer to this query.
>
> Also, it would be nice to still offer SW Tx timestamping, even when
> PTP is disabled.
Yes, I'm aware we should do that, but I also want to resolve the feature
gap between in-tree and out-of-tree versions first.
[...]
> > +/* Process times received from MC.
> > + *
> > + * Extract times from returned results, and establish the minimum value
> > + * seen. The minimum value represents the "best" possible time and events
> > + * too much greater than this are rejected - the machine is, perhaps, too
> > + * busy. A number of readings are taken so that, hopefully, at least one good
> > + * synchronisation will be seen in the results.
> > + */
>
> This code looks like it is trying to find the offset between two
> clocks. Is there some reason why you cannot use <linux/timecompare.h>
> to accomplish this?
>
> Also, these comments about "hopefull" synchronization make me
> nervous. I think it might be easier just to offer RAW timestamps and
> forget about the SYS timestamps.
>
> I am trying to purge the whole SYS thing (only blackfin is left)
> because there is a much better way to go about this, namely
> synchronizing the system time to the PHC time via an internal PPS
> signal.
Andrew, would that work for us?
[...]
> > +static int efx_phc_settime(struct ptp_clock_info *ptp,
> > + const struct timespec *e_ts)
> > +{
> > + /* We must provide this function, but we cannot actually set the time */
>
> Huh? You can adjtime, so must be able to settime, too, right?
Unless I missed something, the firmware interface doesn't include an
atomic settime operation. We may be able to fudge it with gettime and
adjtime, if that's good enough.
> If you have enough range in the RAW timestamp in the MC firmware (like
> 64 bits of nanoseconds), and you allow settime, then you can spare the
> system time synchronization code altogether.
[...]
Ben.
--
Ben Hutchings, Staff Engineer, Solarflare
Not speaking for my employer; that's the marketing department's job.
They asked us to note that Solarflare product names are trademarked.
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox