l2t.rar_The Driver

/* * This file is part of the Chelsio T4 Ethernet driver for Linux. * * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved. * * This software is available to you under a choice of one of two * licenses. You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following * disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include <linux/skbuff.h> #include <linux/netdevice.h> #include <linux/if.h> #include <linux/if_vlan.h> #include <linux/jhash.h> #include <linux/module.h> #include <linux/debugfs.h> #include <linux/seq_file.h> #include <net/neighbour.h> #include "cxgb4.h" #include "l2t.h" #include "t4_msg.h" #include "t4fw_api.h" #include "t4_regs.h" #define VLAN_NONE 0xfff /* identifies sync vs async L2T_WRITE_REQs */ #define F_SYNC_WR (1 << 12) enum { L2T_STATE_VALID, /* entry is up to date */ L2T_STATE_STALE, /* entry may be used but needs revalidation */ L2T_STATE_RESOLVING, /* entry needs address resolution */ L2T_STATE_SYNC_WRITE, /* synchronous write of entry underway */ /* when state is one of the below the entry is not hashed */ L2T_STATE_SWITCHING, /* entry is being used by a switching filter */ L2T_STATE_UNUSED /* entry not in use */ }; struct l2t_data { rwlock_t lock; atomic_t nfree; /* number of free entries */ struct l2t_entry *rover; /* starting point for next allocation */ struct l2t_entry l2tab[L2T_SIZE]; }; static inline unsigned int vlan_prio(const struct l2t_entry *e) { return e->vlan >> 13; } static inline void l2t_hold(struct l2t_data *d, struct l2t_entry *e) { if (atomic_add_return(1, &e->refcnt) == 1) /* 0 -> 1 transition */ atomic_dec(&d->nfree); } /* * To avoid having to check address families we do not allow v4 and v6 * neighbors to be on the same hash chain. We keep v4 entries in the first * half of available hash buckets and v6 in the second. */ enum { L2T_SZ_HALF = L2T_SIZE / 2, L2T_HASH_MASK = L2T_SZ_HALF - 1 }; static inline unsigned int arp_hash(const u32 *key, int ifindex) { return jhash_2words(*key, ifindex, 0) & L2T_HASH_MASK; } static inline unsigned int ipv6_hash(const u32 *key, int ifindex) { u32 xor = key[0] ^ key[1] ^ key[2] ^ key[3]; return L2T_SZ_HALF + (jhash_2words(xor, ifindex, 0) & L2T_HASH_MASK); } static unsigned int addr_hash(const u32 *addr, int addr_len, int ifindex) { return addr_len == 4 ? arp_hash(addr, ifindex) : ipv6_hash(addr, ifindex); } /* * Checks if an L2T entry is for the given IP/IPv6 address. It does not check * whether the L2T entry and the address are of the same address family. * Callers ensure an address is only checked against L2T entries of the same * family, something made trivial by the separation of IP and IPv6 hash chains * mentioned above. Returns 0 if there's a match, */ static int addreq(const struct l2t_entry *e, const u32 *addr) { if (e->v6) return (e->addr[0] ^ addr[0]) | (e->addr[1] ^ addr[1]) | (e->addr[2] ^ addr[2]) | (e->addr[3] ^ addr[3]); return e->addr[0] ^ addr[0]; } static void neigh_replace(struct l2t_entry *e, struct neighbour *n) { neigh_hold(n); if (e->neigh) neigh_release(e->neigh); e->neigh = n; } /* * Write an L2T entry. Must be called with the entry locked. * The write may be synchronous or asynchronous. */ static int write_l2e(struct adapter *adap, struct l2t_entry *e, int sync) { struct sk_buff *skb; struct cpl_l2t_write_req *req; skb = alloc_skb(sizeof(*req), GFP_ATOMIC); if (!skb) return -ENOMEM; req = (struct cpl_l2t_write_req *)__skb_put(skb, sizeof(*req)); INIT_TP_WR(req, 0); OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ, e->idx | (sync ? F_SYNC_WR : 0) | TID_QID(adap->sge.fw_evtq.abs_id))); req->params = htons(L2T_W_PORT(e->lport) | L2T_W_NOREPLY(!sync)); req->l2t_idx = htons(e->idx); req->vlan = htons(e->vlan); if (e->neigh && !(e->neigh->dev->flags & IFF_LOOPBACK)) memcpy(e->dmac, e->neigh->ha, sizeof(e->dmac)); memcpy(req->dst_mac, e->dmac, sizeof(req->dst_mac)); set_wr_txq(skb, CPL_PRIORITY_CONTROL, 0); t4_ofld_send(adap, skb); if (sync && e->state != L2T_STATE_SWITCHING) e->state = L2T_STATE_SYNC_WRITE; return 0; } /* * Send packets waiting in an L2T entry's ARP queue. Must be called with the * entry locked. */ static void send_pending(struct adapter *adap, struct l2t_entry *e) { while (e->arpq_head) { struct sk_buff *skb = e->arpq_head; e->arpq_head = skb->next; skb->next = NULL; t4_ofld_send(adap, skb); } e->arpq_tail = NULL; } /* * Process a CPL_L2T_WRITE_RPL. Wake up the ARP queue if it completes a * synchronous L2T_WRITE. Note that the TID in the reply is really the L2T * index it refers to. */ void do_l2t_write_rpl(struct adapter *adap, const struct cpl_l2t_write_rpl *rpl) { unsigned int tid = GET_TID(rpl); unsigned int idx = tid & (L2T_SIZE - 1); if (unlikely(rpl->status != CPL_ERR_NONE)) { dev_err(adap->pdev_dev, "Unexpected L2T_WRITE_RPL status %u for entry %u\n", rpl->status, idx); return; } if (tid & F_SYNC_WR) { struct l2t_entry *e = &adap->l2t->l2tab[idx]; spin_lock(&e->lock); if (e->state != L2T_STATE_SWITCHING) { send_pending(adap, e); e->state = (e->neigh->nud_state & NUD_STALE) ? L2T_STATE_STALE : L2T_STATE_VALID; } spin_unlock(&e->lock); } } /* * Add a packet to an L2T entry's queue of packets awaiting resolution. * Must be called with the entry's lock held. */ static inline void arpq_enqueue(struct l2t_entry *e, struct sk_buff *skb) { skb->next = NULL; if (e->arpq_head) e->arpq_tail->next = skb; else e->arpq_head = skb; e->arpq_tail = skb; } int cxgb4_l2t_send(struct net_device *dev, struct sk_buff *skb, struct l2t_entry *e) { struct adapter *adap = netdev2adap(dev); again: switch (e->state) { case L2T_STATE_STALE: /* entry is stale, kick off revalidation */ neigh_event_send(e->neigh, NULL); spin_lock_bh(&e->lock); if (e->state == L2T_STATE_STALE) e->state = L2T_STATE_VALID; spin_unlock_bh(&e->lock); case L2T_STATE_VALID: /* fast-path, send the packet on */ return t4_ofld_send(adap, skb); case L2T_STATE_RESOLVING: case L2T_STATE_SYNC_WRITE: spin_lock_bh(&e->lock); if (e->state != L2T_STATE_SYNC_WRITE && e->state != L2T_STATE_RESOLVING) { spin_unlock_bh(&e->lock); goto again; } arpq_enqueue(e, skb); spin_unlock_bh(&e->lock); if (e->state == L2T_STATE_RESOLVING && !neigh_event_send(e->neigh, NULL)) { spin_lock_bh(&e->lock); if (e->state == L2T_STATE_RESOLVING && e->arpq_head) write_l2e(adap, e, 1); spin_unlock_bh(&e->lock); } } return 0; } EXPORT_SYMBOL(cxgb4_l2t_send); /* * Allocate a free L2T entry. Must be called with l2t_data.lock held. */ static struct l2t_entry *alloc_l2e(struct l2t_data *d) { struct l2t_entry *end, *e, **p; if