/* * Copyright (c) 2003-2008 Chelsio, 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/slab.h> #include <linux/export.h> #include <net/neighbour.h> #include "common.h" #include "t3cdev.h" #include "cxgb3_defs.h" #include "l2t.h" #include "t3_cpl.h" #include "firmware_exports.h" #define VLAN_NONE … /* * Module locking notes: There is a RW lock protecting the L2 table as a * whole plus a spinlock per L2T entry. Entry lookups and allocations happen * under the protection of the table lock, individual entry changes happen * while holding that entry's spinlock. The table lock nests outside the * entry locks. Allocations of new entries take the table lock as writers so * no other lookups can happen while allocating new entries. Entry updates * take the table lock as readers so multiple entries can be updated in * parallel. An L2T entry can be dropped by decrementing its reference count * and therefore can happen in parallel with entry allocation but no entry * can change state or increment its ref count during allocation as both of * these perform lookups. */ static inline unsigned int vlan_prio(const struct l2t_entry *e) { … } static inline unsigned int arp_hash(u32 key, int ifindex, const struct l2t_data *d) { … } static inline void neigh_replace(struct l2t_entry *e, struct neighbour *n) { … } /* * Set up an L2T entry and send any packets waiting in the arp queue. The * supplied skb is used for the CPL_L2T_WRITE_REQ. Must be called with the * entry locked. */ static int setup_l2e_send_pending(struct t3cdev *dev, struct sk_buff *skb, struct l2t_entry *e) { … } /* * Add a packet to the 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) { … } int t3_l2t_send_slow(struct t3cdev *dev, struct sk_buff *skb, struct l2t_entry *e) { … } EXPORT_SYMBOL(…); void t3_l2t_send_event(struct t3cdev *dev, struct l2t_entry *e) { … } EXPORT_SYMBOL(…); /* * Allocate a free L2T entry. Must be called with l2t_data.lock held. */ static struct l2t_entry *alloc_l2e(struct l2t_data *d) { … } /* * Called when an L2T entry has no more users. The entry is left in the hash * table since it is likely to be reused but we also bump nfree to indicate * that the entry can be reallocated for a different neighbor. We also drop * the existing neighbor reference in case the neighbor is going away and is * waiting on our reference. * * Because entries can be reallocated to other neighbors once their ref count * drops to 0 we need to take the entry's lock to avoid races with a new * incarnation. */ void t3_l2e_free(struct l2t_data *d, struct l2t_entry *e) { … } EXPORT_SYMBOL(…); /* * Update an L2T entry that was previously used for the same next hop as neigh. * Must be called with softirqs disabled. */ static inline void reuse_entry(struct l2t_entry *e, struct neighbour *neigh) { … } struct l2t_entry *t3_l2t_get(struct t3cdev *cdev, struct dst_entry *dst, struct net_device *dev, const void *daddr) { … } EXPORT_SYMBOL(…); /* * Called when address resolution fails for an L2T entry to handle packets * on the arpq head. If a packet specifies a failure handler it is invoked, * otherwise the packets is sent to the offload device. * * XXX: maybe we should abandon the latter behavior and just require a failure * handler. */ static void handle_failed_resolution(struct t3cdev *dev, struct sk_buff_head *arpq) { … } /* * Called when the host's ARP layer makes a change to some entry that is * loaded into the HW L2 table. */ void t3_l2t_update(struct t3cdev *dev, struct neighbour *neigh) { … } struct l2t_data *t3_init_l2t(unsigned int l2t_capacity) { … }
Codebase Browser
linux