2010-09-03 18:29:30 +00:00
|
|
|
/*
|
2010-09-03 18:29:53 +00:00
|
|
|
* IBM Power Virtual Ethernet Device Driver
|
2010-09-03 18:29:30 +00:00
|
|
|
*
|
2010-09-03 18:29:53 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
2010-09-03 18:29:30 +00:00
|
|
|
*
|
2010-09-03 18:29:53 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2010-09-03 18:29:30 +00:00
|
|
|
*
|
2010-09-03 18:29:53 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
2013-12-06 14:28:43 +00:00
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2010-09-03 18:29:30 +00:00
|
|
|
*
|
2010-09-03 18:29:53 +00:00
|
|
|
* Copyright (C) IBM Corporation, 2003, 2010
|
|
|
|
*
|
|
|
|
* Authors: Dave Larson <larson1@us.ibm.com>
|
|
|
|
* Santiago Leon <santil@linux.vnet.ibm.com>
|
|
|
|
* Brian King <brking@linux.vnet.ibm.com>
|
|
|
|
* Robert Jennings <rcj@linux.vnet.ibm.com>
|
|
|
|
* Anton Blanchard <anton@au.ibm.com>
|
2010-09-03 18:29:30 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/init.h>
|
2011-06-06 10:43:46 +00:00
|
|
|
#include <linux/interrupt.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/mm.h>
|
2010-05-07 08:56:08 +00:00
|
|
|
#include <linux/pm.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/ethtool.h>
|
2007-09-15 20:36:07 +00:00
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/ip.h>
|
2010-09-03 18:28:52 +00:00
|
|
|
#include <linux/ipv6.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/hvcall.h>
|
2011-07-26 23:09:06 +00:00
|
|
|
#include <linux/atomic.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/vio.h>
|
2008-07-23 18:34:52 +00:00
|
|
|
#include <asm/iommu.h>
|
|
|
|
#include <asm/firmware.h>
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
#include <net/tcp.h>
|
|
|
|
#include <net/ip6_checksum.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include "ibmveth.h"
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance);
|
2007-04-17 03:12:55 +00:00
|
|
|
static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
|
2008-07-23 18:34:52 +00:00
|
|
|
static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev);
|
2010-09-03 18:29:08 +00:00
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
static struct kobj_type ktype_veth_pool;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-23 18:34:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static const char ibmveth_driver_name[] = "ibmveth";
|
2010-09-03 18:29:53 +00:00
|
|
|
static const char ibmveth_driver_string[] = "IBM Power Virtual Ethernet Driver";
|
2016-12-08 22:40:03 +00:00
|
|
|
#define ibmveth_driver_version "1.06"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:53 +00:00
|
|
|
MODULE_AUTHOR("Santiago Leon <santil@linux.vnet.ibm.com>");
|
|
|
|
MODULE_DESCRIPTION("IBM Power Virtual Ethernet Driver");
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_VERSION(ibmveth_driver_version);
|
|
|
|
|
2010-09-03 18:28:20 +00:00
|
|
|
static unsigned int tx_copybreak __read_mostly = 128;
|
|
|
|
module_param(tx_copybreak, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(tx_copybreak,
|
|
|
|
"Maximum size of packet that is copied to a new buffer on transmit");
|
|
|
|
|
2010-09-03 18:28:25 +00:00
|
|
|
static unsigned int rx_copybreak __read_mostly = 128;
|
|
|
|
module_param(rx_copybreak, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(rx_copybreak,
|
|
|
|
"Maximum size of packet that is copied to a new buffer on receive");
|
|
|
|
|
2010-09-03 18:28:41 +00:00
|
|
|
static unsigned int rx_flush __read_mostly = 0;
|
|
|
|
module_param(rx_flush, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(rx_flush, "Flush receive buffers before use");
|
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
static bool old_large_send __read_mostly;
|
2018-03-23 23:34:44 +00:00
|
|
|
module_param(old_large_send, bool, 0444);
|
2015-07-14 15:51:51 +00:00
|
|
|
MODULE_PARM_DESC(old_large_send,
|
|
|
|
"Use old large send method on firmware that supports the new method");
|
|
|
|
|
2007-08-17 14:16:43 +00:00
|
|
|
struct ibmveth_stat {
|
|
|
|
char name[ETH_GSTRING_LEN];
|
|
|
|
int offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
|
|
|
|
#define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
|
|
|
|
|
2019-03-19 14:42:37 +00:00
|
|
|
static struct ibmveth_stat ibmveth_stats[] = {
|
2007-08-17 14:16:43 +00:00
|
|
|
{ "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles) },
|
|
|
|
{ "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem) },
|
2010-09-03 18:29:30 +00:00
|
|
|
{ "replenish_add_buff_failure",
|
|
|
|
IBMVETH_STAT_OFF(replenish_add_buff_failure) },
|
|
|
|
{ "replenish_add_buff_success",
|
|
|
|
IBMVETH_STAT_OFF(replenish_add_buff_success) },
|
2007-08-17 14:16:43 +00:00
|
|
|
{ "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer) },
|
|
|
|
{ "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer) },
|
|
|
|
{ "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) },
|
|
|
|
{ "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) },
|
2010-09-03 18:28:52 +00:00
|
|
|
{ "fw_enabled_ipv4_csum", IBMVETH_STAT_OFF(fw_ipv4_csum_support) },
|
|
|
|
{ "fw_enabled_ipv6_csum", IBMVETH_STAT_OFF(fw_ipv6_csum_support) },
|
2015-04-29 21:25:45 +00:00
|
|
|
{ "tx_large_packets", IBMVETH_STAT_OFF(tx_large_packets) },
|
2015-07-14 15:51:51 +00:00
|
|
|
{ "rx_large_packets", IBMVETH_STAT_OFF(rx_large_packets) },
|
|
|
|
{ "fw_enabled_large_send", IBMVETH_STAT_OFF(fw_large_send_support) }
|
2007-08-17 14:16:43 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* simple methods of getting data from the current rxq entry */
|
2007-08-17 14:16:56 +00:00
|
|
|
static inline u32 ibmveth_rxq_flags(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2013-09-02 23:55:32 +00:00
|
|
|
return be32_to_cpu(adapter->rx_queue.queue_addr[adapter->rx_queue.index].flags_off);
|
2007-08-17 14:16:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_toggle(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2010-09-03 18:29:30 +00:00
|
|
|
return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >>
|
|
|
|
IBMVETH_RXQ_TOGGLE_SHIFT;
|
2007-08-17 14:16:56 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2010-09-03 18:29:30 +00:00
|
|
|
return ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2010-09-03 18:29:30 +00:00
|
|
|
return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2010-09-03 18:29:30 +00:00
|
|
|
return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-12-08 22:40:03 +00:00
|
|
|
static inline int ibmveth_rxq_large_packet(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_LRG_PKT;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2013-09-02 23:55:32 +00:00
|
|
|
return be32_to_cpu(adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 20:36:07 +00:00
|
|
|
static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2010-09-03 18:29:30 +00:00
|
|
|
return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_CSUM_GOOD;
|
2007-09-15 20:36:07 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* setup the initial settings for a buffer pool */
|
2010-09-03 18:29:30 +00:00
|
|
|
static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool,
|
|
|
|
u32 pool_index, u32 pool_size,
|
|
|
|
u32 buff_size, u32 pool_active)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
pool->size = pool_size;
|
|
|
|
pool->index = pool_index;
|
|
|
|
pool->buff_size = buff_size;
|
2010-09-03 18:28:09 +00:00
|
|
|
pool->threshold = pool_size * 7 / 8;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
pool->active = pool_active;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate and setup an buffer pool - called during open */
|
|
|
|
static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 20:55:00 +00:00
|
|
|
pool->free_map = kmalloc_array(pool->size, sizeof(u16), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!pool->free_map)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
|
|
|
|
2015-12-20 14:06:18 +00:00
|
|
|
pool->dma_addr = kcalloc(pool->size, sizeof(dma_addr_t), GFP_KERNEL);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!pool->dma_addr) {
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(pool->free_map);
|
|
|
|
pool->free_map = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
drivers/net: Use kcalloc or kzalloc
Use kcalloc or kzalloc rather than the combination of kmalloc and memset.
The semantic patch that makes this change is as follows:
(http://coccinelle.lip6.fr/)
// <smpl>
@@
expression x,y,flags;
statement S;
type T;
@@
x =
- kmalloc
+ kcalloc
(
- y * sizeof(T),
+ y, sizeof(T),
flags);
if (x == NULL) S
-memset(x, 0, y * sizeof(T));
@@
expression x,size,flags;
statement S;
@@
-x = kmalloc(size,flags);
+x = kzalloc(size,flags);
if (x == NULL) S
-memset(x, 0, size);
// </smpl>
Signed-off-by: Julia Lawall <julia@diku.dk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-05-13 10:06:01 +00:00
|
|
|
pool->skbuff = kcalloc(pool->size, sizeof(void *), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!pool->skbuff) {
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(pool->dma_addr);
|
|
|
|
pool->dma_addr = NULL;
|
|
|
|
|
|
|
|
kfree(pool->free_map);
|
|
|
|
pool->free_map = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
for (i = 0; i < pool->size; ++i)
|
2005-04-16 22:20:36 +00:00
|
|
|
pool->free_map[i] = i;
|
|
|
|
|
|
|
|
atomic_set(&pool->available, 0);
|
|
|
|
pool->producer_index = 0;
|
|
|
|
pool->consumer_index = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:28:41 +00:00
|
|
|
static inline void ibmveth_flush_buffer(void *addr, unsigned long length)
|
|
|
|
{
|
|
|
|
unsigned long offset;
|
|
|
|
|
|
|
|
for (offset = 0; offset < length; offset += SMP_CACHE_BYTES)
|
|
|
|
asm("dcbfl %0,%1" :: "b" (addr), "r" (offset));
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* replenish the buffers for a pool. note that we don't need to
|
|
|
|
* skb_reserve these since they are used for incoming...
|
|
|
|
*/
|
2010-09-03 18:29:30 +00:00
|
|
|
static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter,
|
|
|
|
struct ibmveth_buff_pool *pool)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
u32 count = pool->size - atomic_read(&pool->available);
|
|
|
|
u32 buffers_added = 0;
|
2008-07-23 18:34:52 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned int free_index, index;
|
|
|
|
u64 correlator;
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
dma_addr_t dma_addr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
mb();
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
for (i = 0; i < count; ++i) {
|
2005-04-16 22:20:36 +00:00
|
|
|
union ibmveth_buf_desc desc;
|
|
|
|
|
2010-09-03 18:29:03 +00:00
|
|
|
skb = netdev_alloc_skb(adapter->netdev, pool->buff_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!skb) {
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(adapter->netdev,
|
|
|
|
"replenish: unable to allocate skb\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->replenish_no_mem++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-10-21 17:24:13 +00:00
|
|
|
free_index = pool->consumer_index;
|
2010-09-03 18:28:04 +00:00
|
|
|
pool->consumer_index++;
|
|
|
|
if (pool->consumer_index >= pool->size)
|
|
|
|
pool->consumer_index = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
index = pool->free_map[free_index];
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(index == IBM_VETH_INVALID_MAP);
|
|
|
|
BUG_ON(pool->skbuff[index] != NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
|
|
|
|
pool->buff_size, DMA_FROM_DEVICE);
|
|
|
|
|
2008-07-27 16:14:24 +00:00
|
|
|
if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
|
2008-07-23 18:34:52 +00:00
|
|
|
goto failure;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
|
|
|
|
pool->dma_addr[index] = dma_addr;
|
|
|
|
pool->skbuff[index] = skb;
|
|
|
|
|
|
|
|
correlator = ((u64)pool->index << 32) | index;
|
2010-09-03 18:29:30 +00:00
|
|
|
*(u64 *)skb->data = correlator;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-17 14:16:56 +00:00
|
|
|
desc.fields.flags_len = IBMVETH_BUF_VALID | pool->buff_size;
|
2006-05-24 05:31:14 +00:00
|
|
|
desc.fields.address = dma_addr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:28:41 +00:00
|
|
|
if (rx_flush) {
|
|
|
|
unsigned int len = min(pool->buff_size,
|
|
|
|
adapter->netdev->mtu +
|
|
|
|
IBMVETH_BUFF_OH);
|
|
|
|
ibmveth_flush_buffer(skb->data, len);
|
|
|
|
}
|
2010-09-03 18:29:30 +00:00
|
|
|
lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address,
|
|
|
|
desc.desc);
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2008-07-23 18:34:52 +00:00
|
|
|
goto failure;
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2005-04-16 22:20:36 +00:00
|
|
|
buffers_added++;
|
|
|
|
adapter->replenish_add_buff_success++;
|
|
|
|
}
|
|
|
|
}
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2008-07-23 18:34:52 +00:00
|
|
|
mb();
|
|
|
|
atomic_add(buffers_added, &(pool->available));
|
|
|
|
return;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
pool->free_map[free_index] = index;
|
|
|
|
pool->skbuff[index] = NULL;
|
|
|
|
if (pool->consumer_index == 0)
|
|
|
|
pool->consumer_index = pool->size - 1;
|
|
|
|
else
|
|
|
|
pool->consumer_index--;
|
2008-07-27 16:14:24 +00:00
|
|
|
if (!dma_mapping_error(&adapter->vdev->dev, dma_addr))
|
2008-07-23 18:34:52 +00:00
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
pool->dma_addr[index], pool->buff_size,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
adapter->replenish_add_buff_failure++;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
mb();
|
|
|
|
atomic_add(buffers_added, &(pool->available));
|
|
|
|
}
|
|
|
|
|
2014-08-22 01:36:52 +00:00
|
|
|
/*
|
|
|
|
* The final 8 bytes of the buffer list is a counter of frames dropped
|
|
|
|
* because there was not a buffer in the buffer list capable of holding
|
|
|
|
* the frame.
|
|
|
|
*/
|
|
|
|
static void ibmveth_update_rx_no_buffer(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
__be64 *p = adapter->buffer_list_addr + 4096 - 8;
|
|
|
|
|
|
|
|
adapter->rx_no_buffer = be64_to_cpup(p);
|
|
|
|
}
|
|
|
|
|
2005-10-26 16:47:08 +00:00
|
|
|
/* replenish routine */
|
2006-05-24 05:31:14 +00:00
|
|
|
static void ibmveth_replenish_task(struct ibmveth_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-10-26 16:47:01 +00:00
|
|
|
int i;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->replenish_task_cycles++;
|
|
|
|
|
2010-09-03 18:29:25 +00:00
|
|
|
for (i = (IBMVETH_NUM_BUFF_POOLS - 1); i >= 0; i--) {
|
2010-09-03 18:28:09 +00:00
|
|
|
struct ibmveth_buff_pool *pool = &adapter->rx_buff_pool[i];
|
|
|
|
|
|
|
|
if (pool->active &&
|
|
|
|
(atomic_read(&pool->available) < pool->threshold))
|
|
|
|
ibmveth_replenish_buffer_pool(adapter, pool);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-08-22 01:36:52 +00:00
|
|
|
ibmveth_update_rx_no_buffer(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* empty and free ana buffer pool - also used to do cleanup in error paths */
|
2010-09-03 18:29:30 +00:00
|
|
|
static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter,
|
|
|
|
struct ibmveth_buff_pool *pool)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-10-28 20:53:13 +00:00
|
|
|
kfree(pool->free_map);
|
|
|
|
pool->free_map = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (pool->skbuff && pool->dma_addr) {
|
|
|
|
for (i = 0; i < pool->size; ++i) {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct sk_buff *skb = pool->skbuff[i];
|
2010-09-03 18:29:30 +00:00
|
|
|
if (skb) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
pool->dma_addr[i],
|
|
|
|
pool->buff_size,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
pool->skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (pool->dma_addr) {
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(pool->dma_addr);
|
|
|
|
pool->dma_addr = NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (pool->skbuff) {
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(pool->skbuff);
|
|
|
|
pool->skbuff = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove a buffer from a pool */
|
2010-09-03 18:29:30 +00:00
|
|
|
static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter,
|
|
|
|
u64 correlator)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int pool = correlator >> 32;
|
|
|
|
unsigned int index = correlator & 0xffffffffUL;
|
|
|
|
unsigned int free_index;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
|
|
|
|
BUG_ON(index >= adapter->rx_buff_pool[pool].size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
skb = adapter->rx_buff_pool[pool].skbuff[index];
|
|
|
|
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(skb == NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
adapter->rx_buff_pool[pool].skbuff[index] = NULL;
|
|
|
|
|
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
adapter->rx_buff_pool[pool].dma_addr[index],
|
|
|
|
adapter->rx_buff_pool[pool].buff_size,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
|
2006-10-21 17:24:13 +00:00
|
|
|
free_index = adapter->rx_buff_pool[pool].producer_index;
|
2010-09-03 18:28:04 +00:00
|
|
|
adapter->rx_buff_pool[pool].producer_index++;
|
|
|
|
if (adapter->rx_buff_pool[pool].producer_index >=
|
|
|
|
adapter->rx_buff_pool[pool].size)
|
|
|
|
adapter->rx_buff_pool[pool].producer_index = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->rx_buff_pool[pool].free_map[free_index] = index;
|
|
|
|
|
|
|
|
mb();
|
|
|
|
|
|
|
|
atomic_dec(&(adapter->rx_buff_pool[pool].available));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get the current buffer on the rx queue */
|
|
|
|
static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
u64 correlator = adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator;
|
|
|
|
unsigned int pool = correlator >> 32;
|
|
|
|
unsigned int index = correlator & 0xffffffffUL;
|
|
|
|
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
|
|
|
|
BUG_ON(index >= adapter->rx_buff_pool[pool].size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return adapter->rx_buff_pool[pool].skbuff[index];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* recycle the current buffer on the rx queue */
|
2011-08-25 00:56:15 +00:00
|
|
|
static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 q_index = adapter->rx_queue.index;
|
|
|
|
u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator;
|
|
|
|
unsigned int pool = correlator >> 32;
|
|
|
|
unsigned int index = correlator & 0xffffffffUL;
|
|
|
|
union ibmveth_buf_desc desc;
|
|
|
|
unsigned long lpar_rc;
|
2011-08-25 00:56:15 +00:00
|
|
|
int ret = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
|
|
|
|
BUG_ON(index >= adapter->rx_buff_pool[pool].size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!adapter->rx_buff_pool[pool].active) {
|
2005-10-26 16:47:01 +00:00
|
|
|
ibmveth_rxq_harvest_buffer(adapter);
|
|
|
|
ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
|
2011-08-25 00:56:15 +00:00
|
|
|
goto out;
|
2005-10-26 16:47:01 +00:00
|
|
|
}
|
|
|
|
|
2007-08-17 14:16:56 +00:00
|
|
|
desc.fields.flags_len = IBMVETH_BUF_VALID |
|
|
|
|
adapter->rx_buff_pool[pool].buff_size;
|
2005-04-16 22:20:36 +00:00
|
|
|
desc.fields.address = adapter->rx_buff_pool[pool].dma_addr[index];
|
|
|
|
|
|
|
|
lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(adapter->netdev, "h_add_logical_lan_buffer failed "
|
|
|
|
"during recycle rc=%ld", lpar_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
|
2011-08-25 00:56:15 +00:00
|
|
|
ret = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->rx_queue.index = 0;
|
|
|
|
adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
|
|
|
|
}
|
2011-08-25 00:56:15 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-04-17 03:12:55 +00:00
|
|
|
static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->rx_queue.index = 0;
|
|
|
|
adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-03 17:24:23 +00:00
|
|
|
static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter,
|
|
|
|
union ibmveth_buf_desc rxq_desc, u64 mac_address)
|
|
|
|
{
|
|
|
|
int rc, try_again = 1;
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
/*
|
|
|
|
* After a kexec the adapter will still be open, so our attempt to
|
|
|
|
* open it will fail. So if we get a failure we free the adapter and
|
|
|
|
* try again, but only once.
|
|
|
|
*/
|
2006-10-03 17:24:23 +00:00
|
|
|
retry:
|
|
|
|
rc = h_register_logical_lan(adapter->vdev->unit_address,
|
|
|
|
adapter->buffer_list_dma, rxq_desc.desc,
|
|
|
|
adapter->filter_list_dma, mac_address);
|
|
|
|
|
|
|
|
if (rc != H_SUCCESS && try_again) {
|
|
|
|
do {
|
|
|
|
rc = h_free_logical_lan(adapter->vdev->unit_address);
|
|
|
|
} while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
|
|
|
|
|
|
|
|
try_again = 0;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2014-03-05 03:51:37 +00:00
|
|
|
static u64 ibmveth_encode_mac_addr(u8 *mac)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u64 encoded = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < ETH_ALEN; i++)
|
|
|
|
encoded = (encoded << 8) | mac[i];
|
|
|
|
|
|
|
|
return encoded;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ibmveth_open(struct net_device *netdev)
|
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
2014-03-05 03:51:37 +00:00
|
|
|
u64 mac_address;
|
2005-10-26 16:47:01 +00:00
|
|
|
int rxq_entries = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long lpar_rc;
|
|
|
|
int rc;
|
|
|
|
union ibmveth_buf_desc rxq_desc;
|
2005-10-26 16:47:01 +00:00
|
|
|
int i;
|
2008-07-26 02:44:49 +00:00
|
|
|
struct device *dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "open starting\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
napi_enable(&adapter->napi);
|
|
|
|
|
2010-09-03 18:29:25 +00:00
|
|
|
for(i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
|
2005-10-26 16:47:01 +00:00
|
|
|
rxq_entries += adapter->rx_buff_pool[i].size;
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2017-05-21 10:45:58 +00:00
|
|
|
rc = -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
|
2017-05-21 10:45:58 +00:00
|
|
|
if (!adapter->buffer_list_addr) {
|
|
|
|
netdev_err(netdev, "unable to allocate list pages\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2017-05-21 10:45:58 +00:00
|
|
|
adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
|
|
|
|
if (!adapter->filter_list_addr) {
|
|
|
|
netdev_err(netdev, "unable to allocate filter pages\n");
|
|
|
|
goto out_free_buffer_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-09-04 14:41:37 +00:00
|
|
|
dev = &adapter->vdev->dev;
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) *
|
|
|
|
rxq_entries;
|
2012-09-04 14:41:37 +00:00
|
|
|
adapter->rx_queue.queue_addr =
|
2013-03-14 13:07:21 +00:00
|
|
|
dma_alloc_coherent(dev, adapter->rx_queue.queue_len,
|
|
|
|
&adapter->rx_queue.queue_dma, GFP_KERNEL);
|
2017-05-21 10:45:58 +00:00
|
|
|
if (!adapter->rx_queue.queue_addr)
|
|
|
|
goto out_free_filter_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-26 02:44:49 +00:00
|
|
|
adapter->buffer_list_dma = dma_map_single(dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL);
|
2017-05-21 10:45:58 +00:00
|
|
|
if (dma_mapping_error(dev, adapter->buffer_list_dma)) {
|
|
|
|
netdev_err(netdev, "unable to map buffer list pages\n");
|
|
|
|
goto out_free_queue_mem;
|
|
|
|
}
|
|
|
|
|
2008-07-26 02:44:49 +00:00
|
|
|
adapter->filter_list_dma = dma_map_single(dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL);
|
2017-05-21 10:45:58 +00:00
|
|
|
if (dma_mapping_error(dev, adapter->filter_list_dma)) {
|
|
|
|
netdev_err(netdev, "unable to map filter list pages\n");
|
|
|
|
goto out_unmap_buffer_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
adapter->rx_queue.index = 0;
|
|
|
|
adapter->rx_queue.num_slots = rxq_entries;
|
|
|
|
adapter->rx_queue.toggle = 1;
|
|
|
|
|
2014-03-05 03:51:37 +00:00
|
|
|
mac_address = ibmveth_encode_mac_addr(netdev->dev_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
rxq_desc.fields.flags_len = IBMVETH_BUF_VALID |
|
|
|
|
adapter->rx_queue.queue_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
rxq_desc.fields.address = adapter->rx_queue.queue_dma;
|
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "buffer list @ 0x%p\n", adapter->buffer_list_addr);
|
|
|
|
netdev_dbg(netdev, "filter list @ 0x%p\n", adapter->filter_list_addr);
|
|
|
|
netdev_dbg(netdev, "receive q @ 0x%p\n", adapter->rx_queue.queue_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-03 17:24:34 +00:00
|
|
|
h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
|
|
|
|
|
2006-10-03 17:24:23 +00:00
|
|
|
lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "h_register_logical_lan failed with %ld\n",
|
|
|
|
lpar_rc);
|
|
|
|
netdev_err(netdev, "buffer TCE:0x%llx filter TCE:0x%llx rxq "
|
|
|
|
"desc:0x%llx MAC:0x%llx\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->buffer_list_dma,
|
|
|
|
adapter->filter_list_dma,
|
|
|
|
rxq_desc.desc,
|
|
|
|
mac_address);
|
2010-10-20 04:21:13 +00:00
|
|
|
rc = -ENONET;
|
2017-05-21 10:45:58 +00:00
|
|
|
goto out_unmap_filter_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
|
|
|
|
if (!adapter->rx_buff_pool[i].active)
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
continue;
|
|
|
|
if (ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[i])) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "unable to alloc pool\n");
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
adapter->rx_buff_pool[i].active = 0;
|
2010-10-20 04:21:13 +00:00
|
|
|
rc = -ENOMEM;
|
2017-05-21 10:45:58 +00:00
|
|
|
goto out_free_buffer_pools;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "registering irq 0x%x\n", netdev->irq);
|
2010-09-03 18:29:30 +00:00
|
|
|
rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name,
|
|
|
|
netdev);
|
|
|
|
if (rc != 0) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "unable to request irq 0x%x, rc %d\n",
|
|
|
|
netdev->irq, rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
do {
|
2011-09-28 05:33:43 +00:00
|
|
|
lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
|
|
|
|
} while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-21 10:45:58 +00:00
|
|
|
goto out_free_buffer_pools;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-05-21 10:45:58 +00:00
|
|
|
rc = -ENOMEM;
|
2008-07-23 18:34:52 +00:00
|
|
|
adapter->bounce_buffer =
|
|
|
|
kmalloc(netdev->mtu + IBMVETH_BUFF_OH, GFP_KERNEL);
|
2017-05-21 10:45:58 +00:00
|
|
|
if (!adapter->bounce_buffer)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
2008-07-23 18:34:52 +00:00
|
|
|
adapter->bounce_buffer_dma =
|
|
|
|
dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer,
|
|
|
|
netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL);
|
2008-07-26 02:44:49 +00:00
|
|
|
if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "unable to map bounce buffer\n");
|
2017-05-21 10:45:58 +00:00
|
|
|
goto out_free_bounce_buffer;
|
2008-07-23 18:34:52 +00:00
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "initial replenish cycle\n");
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
ibmveth_interrupt(netdev->irq, netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-26 16:47:08 +00:00
|
|
|
netif_start_queue(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "open complete\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
2010-10-20 04:21:13 +00:00
|
|
|
|
2017-05-21 10:45:58 +00:00
|
|
|
out_free_bounce_buffer:
|
|
|
|
kfree(adapter->bounce_buffer);
|
|
|
|
out_free_irq:
|
2010-10-20 04:21:51 +00:00
|
|
|
free_irq(netdev->irq, netdev);
|
2017-05-21 10:45:58 +00:00
|
|
|
out_free_buffer_pools:
|
|
|
|
while (--i >= 0) {
|
|
|
|
if (adapter->rx_buff_pool[i].active)
|
|
|
|
ibmveth_free_buffer_pool(adapter,
|
|
|
|
&adapter->rx_buff_pool[i]);
|
|
|
|
}
|
|
|
|
out_unmap_filter_list:
|
|
|
|
dma_unmap_single(dev, adapter->filter_list_dma, 4096,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
out_unmap_buffer_list:
|
|
|
|
dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
out_free_queue_mem:
|
|
|
|
dma_free_coherent(dev, adapter->rx_queue.queue_len,
|
|
|
|
adapter->rx_queue.queue_addr,
|
|
|
|
adapter->rx_queue.queue_dma);
|
|
|
|
out_free_filter_list:
|
|
|
|
free_page((unsigned long)adapter->filter_list_addr);
|
|
|
|
out_free_buffer_list:
|
|
|
|
free_page((unsigned long)adapter->buffer_list_addr);
|
|
|
|
out:
|
2010-10-20 04:21:13 +00:00
|
|
|
napi_disable(&adapter->napi);
|
|
|
|
return rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_close(struct net_device *netdev)
|
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
2017-05-21 10:45:58 +00:00
|
|
|
struct device *dev = &adapter->vdev->dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
long lpar_rc;
|
2017-05-21 10:45:58 +00:00
|
|
|
int i;
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "close starting\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
napi_disable(&adapter->napi);
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
if (!adapter->pool_config)
|
|
|
|
netif_stop_queue(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-07-16 04:57:25 +00:00
|
|
|
h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
do {
|
|
|
|
lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
|
2006-03-30 12:49:40 +00:00
|
|
|
} while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "h_free_logical_lan failed with %lx, "
|
|
|
|
"continuing with close\n", lpar_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-07-16 04:57:25 +00:00
|
|
|
free_irq(netdev->irq, netdev);
|
|
|
|
|
2014-08-22 01:36:52 +00:00
|
|
|
ibmveth_update_rx_no_buffer(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-21 10:45:58 +00:00
|
|
|
dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
free_page((unsigned long)adapter->buffer_list_addr);
|
|
|
|
|
|
|
|
dma_unmap_single(dev, adapter->filter_list_dma, 4096,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
free_page((unsigned long)adapter->filter_list_addr);
|
|
|
|
|
|
|
|
dma_free_coherent(dev, adapter->rx_queue.queue_len,
|
|
|
|
adapter->rx_queue.queue_addr,
|
|
|
|
adapter->rx_queue.queue_dma);
|
|
|
|
|
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
|
|
|
|
if (adapter->rx_buff_pool[i].active)
|
|
|
|
ibmveth_free_buffer_pool(adapter,
|
|
|
|
&adapter->rx_buff_pool[i]);
|
|
|
|
|
|
|
|
dma_unmap_single(&adapter->vdev->dev, adapter->bounce_buffer_dma,
|
|
|
|
adapter->netdev->mtu + IBMVETH_BUFF_OH,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
kfree(adapter->bounce_buffer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "close complete\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-07 21:35:13 +00:00
|
|
|
static int netdev_get_link_ksettings(struct net_device *dev,
|
|
|
|
struct ethtool_link_ksettings *cmd)
|
2010-09-03 18:29:30 +00:00
|
|
|
{
|
2017-01-07 21:35:13 +00:00
|
|
|
u32 supported, advertising;
|
|
|
|
|
|
|
|
supported = (SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg |
|
2010-09-03 18:29:30 +00:00
|
|
|
SUPPORTED_FIBRE);
|
2017-01-07 21:35:13 +00:00
|
|
|
advertising = (ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg |
|
2010-09-03 18:29:30 +00:00
|
|
|
ADVERTISED_FIBRE);
|
2017-01-07 21:35:13 +00:00
|
|
|
cmd->base.speed = SPEED_1000;
|
|
|
|
cmd->base.duplex = DUPLEX_FULL;
|
|
|
|
cmd->base.port = PORT_FIBRE;
|
|
|
|
cmd->base.phy_address = 0;
|
|
|
|
cmd->base.autoneg = AUTONEG_ENABLE;
|
|
|
|
|
|
|
|
ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
|
|
|
|
supported);
|
|
|
|
ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
|
|
|
|
advertising);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
static void netdev_get_drvinfo(struct net_device *dev,
|
|
|
|
struct ethtool_drvinfo *info)
|
|
|
|
{
|
2013-01-06 00:44:26 +00:00
|
|
|
strlcpy(info->driver, ibmveth_driver_name, sizeof(info->driver));
|
|
|
|
strlcpy(info->version, ibmveth_driver_version, sizeof(info->version));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static netdev_features_t ibmveth_fix_features(struct net_device *dev,
|
|
|
|
netdev_features_t features)
|
2007-08-17 14:16:31 +00:00
|
|
|
{
|
2011-04-19 02:14:25 +00:00
|
|
|
/*
|
|
|
|
* Since the ibmveth firmware interface does not have the
|
|
|
|
* concept of separate tx/rx checksum offload enable, if rx
|
|
|
|
* checksum is disabled we also have to disable tx checksum
|
|
|
|
* offload. Once we disable rx checksum offload, we are no
|
|
|
|
* longer allowed to send tx buffers that are not properly
|
|
|
|
* checksummed.
|
|
|
|
*/
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2011-04-19 02:14:25 +00:00
|
|
|
if (!(features & NETIF_F_RXCSUM))
|
2015-12-14 19:19:43 +00:00
|
|
|
features &= ~NETIF_F_CSUM_MASK;
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2011-04-19 02:14:25 +00:00
|
|
|
return features;
|
2007-08-17 14:16:31 +00:00
|
|
|
}
|
|
|
|
|
2011-04-19 02:14:25 +00:00
|
|
|
static int ibmveth_set_csum_offload(struct net_device *dev, u32 data)
|
2007-08-17 14:16:31 +00:00
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(dev);
|
2009-01-06 18:47:44 +00:00
|
|
|
unsigned long set_attr, clr_attr, ret_attr;
|
2010-09-03 18:28:52 +00:00
|
|
|
unsigned long set_attr6, clr_attr6;
|
2011-09-07 14:41:06 +00:00
|
|
|
long ret, ret4, ret6;
|
2007-08-17 14:16:31 +00:00
|
|
|
int rc1 = 0, rc2 = 0;
|
|
|
|
int restart = 0;
|
|
|
|
|
|
|
|
if (netif_running(dev)) {
|
|
|
|
restart = 1;
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(dev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
}
|
|
|
|
|
2007-08-17 14:16:56 +00:00
|
|
|
set_attr = 0;
|
|
|
|
clr_attr = 0;
|
2011-09-07 14:41:06 +00:00
|
|
|
set_attr6 = 0;
|
|
|
|
clr_attr6 = 0;
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2010-09-03 18:28:52 +00:00
|
|
|
if (data) {
|
2007-08-17 14:16:56 +00:00
|
|
|
set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
|
2010-09-03 18:28:52 +00:00
|
|
|
set_attr6 = IBMVETH_ILLAN_IPV6_TCP_CSUM;
|
|
|
|
} else {
|
2007-08-17 14:16:56 +00:00
|
|
|
clr_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
|
2010-09-03 18:28:52 +00:00
|
|
|
clr_attr6 = IBMVETH_ILLAN_IPV6_TCP_CSUM;
|
|
|
|
}
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2007-08-17 14:16:56 +00:00
|
|
|
ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
|
2007-08-17 14:16:31 +00:00
|
|
|
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
if (ret == H_SUCCESS &&
|
2007-08-17 14:16:56 +00:00
|
|
|
(ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
|
2011-09-07 14:41:06 +00:00
|
|
|
ret4 = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
|
2007-08-17 14:16:56 +00:00
|
|
|
set_attr, &ret_attr);
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2011-09-07 14:41:06 +00:00
|
|
|
if (ret4 != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(dev, "unable to change IPv4 checksum "
|
|
|
|
"offload settings. %d rc=%ld\n",
|
2011-09-07 14:41:06 +00:00
|
|
|
data, ret4);
|
|
|
|
|
|
|
|
h_illan_attributes(adapter->vdev->unit_address,
|
|
|
|
set_attr, clr_attr, &ret_attr);
|
|
|
|
|
|
|
|
if (data == 1)
|
|
|
|
dev->features &= ~NETIF_F_IP_CSUM;
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2010-09-03 18:28:52 +00:00
|
|
|
adapter->fw_ipv4_csum_support = data;
|
2010-09-03 18:29:30 +00:00
|
|
|
}
|
2010-09-03 18:28:52 +00:00
|
|
|
|
|
|
|
ret6 = h_illan_attributes(adapter->vdev->unit_address,
|
|
|
|
clr_attr6, set_attr6, &ret_attr);
|
|
|
|
|
|
|
|
if (ret6 != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(dev, "unable to change IPv6 checksum "
|
|
|
|
"offload settings. %d rc=%ld\n",
|
2011-09-07 14:41:06 +00:00
|
|
|
data, ret6);
|
|
|
|
|
|
|
|
h_illan_attributes(adapter->vdev->unit_address,
|
|
|
|
set_attr6, clr_attr6, &ret_attr);
|
|
|
|
|
|
|
|
if (data == 1)
|
|
|
|
dev->features &= ~NETIF_F_IPV6_CSUM;
|
2010-09-03 18:28:52 +00:00
|
|
|
|
|
|
|
} else
|
|
|
|
adapter->fw_ipv6_csum_support = data;
|
|
|
|
|
2011-09-07 14:41:06 +00:00
|
|
|
if (ret4 == H_SUCCESS || ret6 == H_SUCCESS)
|
2011-04-19 02:14:25 +00:00
|
|
|
adapter->rx_csum = data;
|
2010-09-03 18:28:52 +00:00
|
|
|
else
|
|
|
|
rc1 = -EIO;
|
2007-08-17 14:16:31 +00:00
|
|
|
} else {
|
|
|
|
rc1 = -EIO;
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(dev, "unable to change checksum offload settings."
|
|
|
|
" %d rc=%ld ret_attr=%lx\n", data, ret,
|
|
|
|
ret_attr);
|
2007-08-17 14:16:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (restart)
|
|
|
|
rc2 = ibmveth_open(dev);
|
|
|
|
|
|
|
|
return rc1 ? rc1 : rc2;
|
|
|
|
}
|
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
static int ibmveth_set_tso(struct net_device *dev, u32 data)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(dev);
|
|
|
|
unsigned long set_attr, clr_attr, ret_attr;
|
|
|
|
long ret1, ret2;
|
|
|
|
int rc1 = 0, rc2 = 0;
|
|
|
|
int restart = 0;
|
|
|
|
|
|
|
|
if (netif_running(dev)) {
|
|
|
|
restart = 1;
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(dev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_attr = 0;
|
|
|
|
clr_attr = 0;
|
|
|
|
|
|
|
|
if (data)
|
|
|
|
set_attr = IBMVETH_ILLAN_LRG_SR_ENABLED;
|
|
|
|
else
|
|
|
|
clr_attr = IBMVETH_ILLAN_LRG_SR_ENABLED;
|
|
|
|
|
|
|
|
ret1 = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
|
|
|
|
|
|
|
|
if (ret1 == H_SUCCESS && (ret_attr & IBMVETH_ILLAN_LRG_SND_SUPPORT) &&
|
|
|
|
!old_large_send) {
|
|
|
|
ret2 = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
|
|
|
|
set_attr, &ret_attr);
|
|
|
|
|
|
|
|
if (ret2 != H_SUCCESS) {
|
|
|
|
netdev_err(dev, "unable to change tso settings. %d rc=%ld\n",
|
|
|
|
data, ret2);
|
|
|
|
|
|
|
|
h_illan_attributes(adapter->vdev->unit_address,
|
|
|
|
set_attr, clr_attr, &ret_attr);
|
|
|
|
|
|
|
|
if (data == 1)
|
|
|
|
dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
|
|
|
|
rc1 = -EIO;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
adapter->fw_large_send_support = data;
|
|
|
|
adapter->large_send = data;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Older firmware version of large send offload does not
|
|
|
|
* support tcp6/ipv6
|
|
|
|
*/
|
|
|
|
if (data == 1) {
|
|
|
|
dev->features &= ~NETIF_F_TSO6;
|
|
|
|
netdev_info(dev, "TSO feature requires all partitions to have updated driver");
|
|
|
|
}
|
|
|
|
adapter->large_send = data;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (restart)
|
|
|
|
rc2 = ibmveth_open(dev);
|
|
|
|
|
|
|
|
return rc1 ? rc1 : rc2;
|
|
|
|
}
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static int ibmveth_set_features(struct net_device *dev,
|
|
|
|
netdev_features_t features)
|
2007-08-17 14:16:31 +00:00
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(dev);
|
2011-04-19 02:14:25 +00:00
|
|
|
int rx_csum = !!(features & NETIF_F_RXCSUM);
|
2015-07-14 15:51:51 +00:00
|
|
|
int large_send = !!(features & (NETIF_F_TSO | NETIF_F_TSO6));
|
|
|
|
int rc1 = 0, rc2 = 0;
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
if (rx_csum != adapter->rx_csum) {
|
|
|
|
rc1 = ibmveth_set_csum_offload(dev, rx_csum);
|
|
|
|
if (rc1 && !adapter->rx_csum)
|
|
|
|
dev->features =
|
2015-12-14 19:19:43 +00:00
|
|
|
features & ~(NETIF_F_CSUM_MASK |
|
|
|
|
NETIF_F_RXCSUM);
|
2015-07-14 15:51:51 +00:00
|
|
|
}
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
if (large_send != adapter->large_send) {
|
|
|
|
rc2 = ibmveth_set_tso(dev, large_send);
|
|
|
|
if (rc2 && !adapter->large_send)
|
|
|
|
dev->features =
|
|
|
|
features & ~(NETIF_F_TSO | NETIF_F_TSO6);
|
|
|
|
}
|
2007-08-17 14:16:31 +00:00
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
return rc1 ? rc1 : rc2;
|
2007-08-17 14:16:31 +00:00
|
|
|
}
|
|
|
|
|
2007-08-17 14:16:43 +00:00
|
|
|
static void ibmveth_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (stringset != ETH_SS_STATS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++, data += ETH_GSTRING_LEN)
|
|
|
|
memcpy(data, ibmveth_stats[i].name, ETH_GSTRING_LEN);
|
|
|
|
}
|
|
|
|
|
2007-10-04 01:07:32 +00:00
|
|
|
static int ibmveth_get_sset_count(struct net_device *dev, int sset)
|
2007-08-17 14:16:43 +00:00
|
|
|
{
|
2007-10-04 01:07:32 +00:00
|
|
|
switch (sset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
return ARRAY_SIZE(ibmveth_stats);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2007-08-17 14:16:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_get_ethtool_stats(struct net_device *dev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
int i;
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(dev);
|
2007-08-17 14:16:43 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++)
|
|
|
|
data[i] = IBMVETH_GET_STAT(adapter, ibmveth_stats[i].offset);
|
|
|
|
}
|
|
|
|
|
2006-09-13 18:30:00 +00:00
|
|
|
static const struct ethtool_ops netdev_ethtool_ops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.get_drvinfo = netdev_get_drvinfo,
|
2010-12-09 12:10:25 +00:00
|
|
|
.get_link = ethtool_op_get_link,
|
2007-08-17 14:16:43 +00:00
|
|
|
.get_strings = ibmveth_get_strings,
|
2007-10-04 01:07:32 +00:00
|
|
|
.get_sset_count = ibmveth_get_sset_count,
|
2007-08-17 14:16:43 +00:00
|
|
|
.get_ethtool_stats = ibmveth_get_ethtool_stats,
|
2017-01-07 21:35:13 +00:00
|
|
|
.get_link_ksettings = netdev_get_link_ksettings,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
|
|
|
|
{
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
|
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
static int ibmveth_send(struct ibmveth_adapter *adapter,
|
2015-07-14 15:51:51 +00:00
|
|
|
union ibmveth_buf_desc *descs, unsigned long mss)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned long correlator;
|
|
|
|
unsigned int retry_count;
|
2010-09-03 18:28:36 +00:00
|
|
|
unsigned long ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The retry count sets a maximum for the number of broadcast and
|
|
|
|
* multicast destinations within the system.
|
|
|
|
*/
|
|
|
|
retry_count = 1024;
|
|
|
|
correlator = 0;
|
|
|
|
do {
|
|
|
|
ret = h_send_logical_lan(adapter->vdev->unit_address,
|
|
|
|
descs[0].desc, descs[1].desc,
|
|
|
|
descs[2].desc, descs[3].desc,
|
|
|
|
descs[4].desc, descs[5].desc,
|
2015-07-14 15:51:51 +00:00
|
|
|
correlator, &correlator, mss,
|
|
|
|
adapter->fw_large_send_support);
|
2010-09-03 18:28:36 +00:00
|
|
|
} while ((ret == H_BUSY) && (retry_count--));
|
|
|
|
|
|
|
|
if (ret != H_SUCCESS && ret != H_DROPPED) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(adapter->netdev, "tx: h_send_logical_lan failed "
|
|
|
|
"with rc=%ld\n", ret);
|
2010-09-03 18:28:36 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2005-10-26 16:47:16 +00:00
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
static netdev_tx_t ibmveth_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
|
|
|
unsigned int desc_flags;
|
|
|
|
union ibmveth_buf_desc descs[6];
|
|
|
|
int last, i;
|
|
|
|
int force_bounce = 0;
|
2011-09-07 14:41:04 +00:00
|
|
|
dma_addr_t dma_addr;
|
2015-07-14 15:51:51 +00:00
|
|
|
unsigned long mss = 0;
|
2010-09-03 18:28:36 +00:00
|
|
|
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
/* veth doesn't handle frag_list, so linearize the skb.
|
|
|
|
* When GRO is enabled SKB's can have frag_list.
|
|
|
|
*/
|
|
|
|
if (adapter->is_active_trunk &&
|
|
|
|
skb_has_frag_list(skb) && __skb_linearize(skb)) {
|
|
|
|
netdev->stats.tx_dropped++;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
/*
|
|
|
|
* veth handles a maximum of 6 segments including the header, so
|
|
|
|
* we have to linearize the skb if there are more than this.
|
|
|
|
*/
|
|
|
|
if (skb_shinfo(skb)->nr_frags > 5 && __skb_linearize(skb)) {
|
|
|
|
netdev->stats.tx_dropped++;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
/* veth can't checksum offload UDP */
|
2007-09-15 20:36:07 +00:00
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL &&
|
2010-09-03 18:28:52 +00:00
|
|
|
((skb->protocol == htons(ETH_P_IP) &&
|
|
|
|
ip_hdr(skb)->protocol != IPPROTO_TCP) ||
|
|
|
|
(skb->protocol == htons(ETH_P_IPV6) &&
|
|
|
|
ipv6_hdr(skb)->nexthdr != IPPROTO_TCP)) &&
|
|
|
|
skb_checksum_help(skb)) {
|
|
|
|
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "tx: failed to checksum packet\n");
|
2010-09-03 18:28:36 +00:00
|
|
|
netdev->stats.tx_dropped++;
|
2007-09-15 20:36:07 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
desc_flags = IBMVETH_BUF_VALID;
|
|
|
|
|
2007-09-15 20:36:07 +00:00
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL) {
|
2010-09-03 18:28:36 +00:00
|
|
|
unsigned char *buf = skb_transport_header(skb) +
|
|
|
|
skb->csum_offset;
|
2007-09-15 20:36:07 +00:00
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
desc_flags |= (IBMVETH_BUF_NO_CSUM | IBMVETH_BUF_CSUM_GOOD);
|
2007-09-15 20:36:07 +00:00
|
|
|
|
|
|
|
/* Need to zero out the checksum */
|
|
|
|
buf[0] = 0;
|
|
|
|
buf[1] = 0;
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
|
|
|
|
if (skb_is_gso(skb) && adapter->fw_large_send_support)
|
|
|
|
desc_flags |= IBMVETH_BUF_LRG_SND;
|
2007-09-15 20:36:07 +00:00
|
|
|
}
|
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
retry_bounce:
|
|
|
|
memset(descs, 0, sizeof(descs));
|
2010-09-03 18:28:20 +00:00
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
/*
|
|
|
|
* If a linear packet is below the rx threshold then
|
|
|
|
* copy it into the static bounce buffer. This avoids the
|
|
|
|
* cost of a TCE insert and remove.
|
|
|
|
*/
|
|
|
|
if (force_bounce || (!skb_is_nonlinear(skb) &&
|
|
|
|
(skb->len < tx_copybreak))) {
|
2008-07-23 18:34:52 +00:00
|
|
|
skb_copy_from_linear_data(skb, adapter->bounce_buffer,
|
|
|
|
skb->len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:28:36 +00:00
|
|
|
descs[0].fields.flags_len = desc_flags | skb->len;
|
|
|
|
descs[0].fields.address = adapter->bounce_buffer_dma;
|
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
if (ibmveth_send(adapter, descs, 0)) {
|
2010-09-03 18:28:36 +00:00
|
|
|
adapter->tx_send_failed++;
|
|
|
|
netdev->stats.tx_dropped++;
|
|
|
|
} else {
|
|
|
|
netdev->stats.tx_packets++;
|
|
|
|
netdev->stats.tx_bytes += skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Map the header */
|
2011-09-07 14:41:04 +00:00
|
|
|
dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
|
|
|
|
skb_headlen(skb), DMA_TO_DEVICE);
|
|
|
|
if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
|
2010-09-03 18:28:36 +00:00
|
|
|
goto map_failed;
|
|
|
|
|
|
|
|
descs[0].fields.flags_len = desc_flags | skb_headlen(skb);
|
2011-09-07 14:41:04 +00:00
|
|
|
descs[0].fields.address = dma_addr;
|
2010-09-03 18:28:36 +00:00
|
|
|
|
|
|
|
/* Map the frags */
|
|
|
|
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
|
2011-10-18 21:00:24 +00:00
|
|
|
const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
|
2010-09-03 18:28:36 +00:00
|
|
|
|
2011-08-31 00:46:53 +00:00
|
|
|
dma_addr = skb_frag_dma_map(&adapter->vdev->dev, frag, 0,
|
2011-10-18 21:00:24 +00:00
|
|
|
skb_frag_size(frag), DMA_TO_DEVICE);
|
2010-09-03 18:28:36 +00:00
|
|
|
|
|
|
|
if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
|
|
|
|
goto map_failed_frags;
|
|
|
|
|
2011-10-18 21:00:24 +00:00
|
|
|
descs[i+1].fields.flags_len = desc_flags | skb_frag_size(frag);
|
2010-09-03 18:28:36 +00:00
|
|
|
descs[i+1].fields.address = dma_addr;
|
|
|
|
}
|
|
|
|
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL && skb_is_gso(skb)) {
|
2015-07-14 15:51:51 +00:00
|
|
|
if (adapter->fw_large_send_support) {
|
|
|
|
mss = (unsigned long)skb_shinfo(skb)->gso_size;
|
|
|
|
adapter->tx_large_packets++;
|
|
|
|
} else if (!skb_is_gso_v6(skb)) {
|
|
|
|
/* Put -1 in the IP checksum to tell phyp it
|
|
|
|
* is a largesend packet. Put the mss in
|
|
|
|
* the TCP checksum.
|
|
|
|
*/
|
|
|
|
ip_hdr(skb)->check = 0xffff;
|
|
|
|
tcp_hdr(skb)->check =
|
|
|
|
cpu_to_be16(skb_shinfo(skb)->gso_size);
|
|
|
|
adapter->tx_large_packets++;
|
|
|
|
}
|
2015-04-29 21:25:45 +00:00
|
|
|
}
|
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
if (ibmveth_send(adapter, descs, mss)) {
|
2010-09-03 18:28:36 +00:00
|
|
|
adapter->tx_send_failed++;
|
|
|
|
netdev->stats.tx_dropped++;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2010-09-03 18:28:36 +00:00
|
|
|
netdev->stats.tx_packets++;
|
|
|
|
netdev->stats.tx_bytes += skb->len;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-09-07 14:41:03 +00:00
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
descs[0].fields.address,
|
|
|
|
descs[0].fields.flags_len & IBMVETH_BUF_LEN_MASK,
|
|
|
|
DMA_TO_DEVICE);
|
|
|
|
|
|
|
|
for (i = 1; i < skb_shinfo(skb)->nr_frags + 1; i++)
|
2010-09-03 18:28:36 +00:00
|
|
|
dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address,
|
|
|
|
descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK,
|
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:28:15 +00:00
|
|
|
out:
|
2014-03-16 00:29:34 +00:00
|
|
|
dev_consume_skb_any(skb);
|
2009-06-23 06:03:08 +00:00
|
|
|
return NETDEV_TX_OK;
|
2010-09-03 18:28:36 +00:00
|
|
|
|
|
|
|
map_failed_frags:
|
|
|
|
last = i+1;
|
2018-12-31 21:43:01 +00:00
|
|
|
for (i = 1; i < last; i++)
|
2010-09-03 18:28:36 +00:00
|
|
|
dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address,
|
|
|
|
descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK,
|
|
|
|
DMA_TO_DEVICE);
|
|
|
|
|
2018-12-31 21:43:01 +00:00
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
descs[0].fields.address,
|
|
|
|
descs[0].fields.flags_len & IBMVETH_BUF_LEN_MASK,
|
|
|
|
DMA_TO_DEVICE);
|
2010-09-03 18:28:36 +00:00
|
|
|
map_failed:
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_CMO))
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "tx: unable to map xmit buffer\n");
|
2010-09-03 18:28:36 +00:00
|
|
|
adapter->tx_map_failed++;
|
2016-03-03 21:22:36 +00:00
|
|
|
if (skb_linearize(skb)) {
|
|
|
|
netdev->stats.tx_dropped++;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-09-03 18:28:36 +00:00
|
|
|
force_bounce = 1;
|
|
|
|
goto retry_bounce;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-12-08 22:40:03 +00:00
|
|
|
static void ibmveth_rx_mss_helper(struct sk_buff *skb, u16 mss, int lrg_pkt)
|
|
|
|
{
|
2016-12-14 00:15:09 +00:00
|
|
|
struct tcphdr *tcph;
|
2016-12-08 22:40:03 +00:00
|
|
|
int offset = 0;
|
2016-12-14 00:15:09 +00:00
|
|
|
int hdr_len;
|
2016-12-08 22:40:03 +00:00
|
|
|
|
|
|
|
/* only TCP packets will be aggregated */
|
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
|
|
|
struct iphdr *iph = (struct iphdr *)skb->data;
|
|
|
|
|
|
|
|
if (iph->protocol == IPPROTO_TCP) {
|
|
|
|
offset = iph->ihl * 4;
|
|
|
|
skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (skb->protocol == htons(ETH_P_IPV6)) {
|
|
|
|
struct ipv6hdr *iph6 = (struct ipv6hdr *)skb->data;
|
|
|
|
|
|
|
|
if (iph6->nexthdr == IPPROTO_TCP) {
|
|
|
|
offset = sizeof(struct ipv6hdr);
|
|
|
|
skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* if mss is not set through Large Packet bit/mss in rx buffer,
|
|
|
|
* expect that the mss will be written to the tcp header checksum.
|
|
|
|
*/
|
2016-12-14 00:15:09 +00:00
|
|
|
tcph = (struct tcphdr *)(skb->data + offset);
|
2016-12-08 22:40:03 +00:00
|
|
|
if (lrg_pkt) {
|
|
|
|
skb_shinfo(skb)->gso_size = mss;
|
|
|
|
} else if (offset) {
|
|
|
|
skb_shinfo(skb)->gso_size = ntohs(tcph->check);
|
|
|
|
tcph->check = 0;
|
|
|
|
}
|
2016-12-14 00:15:09 +00:00
|
|
|
|
|
|
|
if (skb_shinfo(skb)->gso_size) {
|
|
|
|
hdr_len = offset + tcph->doff * 4;
|
|
|
|
skb_shinfo(skb)->gso_segs =
|
|
|
|
DIV_ROUND_UP(skb->len - hdr_len,
|
|
|
|
skb_shinfo(skb)->gso_size);
|
|
|
|
}
|
2016-12-08 22:40:03 +00:00
|
|
|
}
|
|
|
|
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
static void ibmveth_rx_csum_helper(struct sk_buff *skb,
|
|
|
|
struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct iphdr *iph = NULL;
|
|
|
|
struct ipv6hdr *iph6 = NULL;
|
|
|
|
__be16 skb_proto = 0;
|
|
|
|
u16 iphlen = 0;
|
|
|
|
u16 iph_proto = 0;
|
|
|
|
u16 tcphdrlen = 0;
|
|
|
|
|
|
|
|
skb_proto = be16_to_cpu(skb->protocol);
|
|
|
|
|
|
|
|
if (skb_proto == ETH_P_IP) {
|
|
|
|
iph = (struct iphdr *)skb->data;
|
|
|
|
|
|
|
|
/* If the IP checksum is not offloaded and if the packet
|
|
|
|
* is large send, the checksum must be rebuilt.
|
|
|
|
*/
|
|
|
|
if (iph->check == 0xffff) {
|
|
|
|
iph->check = 0;
|
|
|
|
iph->check = ip_fast_csum((unsigned char *)iph,
|
|
|
|
iph->ihl);
|
|
|
|
}
|
|
|
|
|
|
|
|
iphlen = iph->ihl * 4;
|
|
|
|
iph_proto = iph->protocol;
|
|
|
|
} else if (skb_proto == ETH_P_IPV6) {
|
|
|
|
iph6 = (struct ipv6hdr *)skb->data;
|
|
|
|
iphlen = sizeof(struct ipv6hdr);
|
|
|
|
iph_proto = iph6->nexthdr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* In OVS environment, when a flow is not cached, specifically for a
|
|
|
|
* new TCP connection, the first packet information is passed up
|
|
|
|
* the user space for finding a flow. During this process, OVS computes
|
|
|
|
* checksum on the first packet when CHECKSUM_PARTIAL flag is set.
|
|
|
|
*
|
|
|
|
* Given that we zeroed out TCP checksum field in transmit path
|
|
|
|
* (refer ibmveth_start_xmit routine) as we set "no checksum bit",
|
|
|
|
* OVS computed checksum will be incorrect w/o TCP pseudo checksum
|
|
|
|
* in the packet. This leads to OVS dropping the packet and hence
|
|
|
|
* TCP retransmissions are seen.
|
|
|
|
*
|
|
|
|
* So, re-compute TCP pseudo header checksum.
|
|
|
|
*/
|
|
|
|
if (iph_proto == IPPROTO_TCP && adapter->is_active_trunk) {
|
|
|
|
struct tcphdr *tcph = (struct tcphdr *)(skb->data + iphlen);
|
|
|
|
|
|
|
|
tcphdrlen = skb->len - iphlen;
|
|
|
|
|
|
|
|
/* Recompute TCP pseudo header checksum */
|
|
|
|
if (skb_proto == ETH_P_IP)
|
|
|
|
tcph->check = ~csum_tcpudp_magic(iph->saddr,
|
|
|
|
iph->daddr, tcphdrlen, iph_proto, 0);
|
|
|
|
else if (skb_proto == ETH_P_IPV6)
|
|
|
|
tcph->check = ~csum_ipv6_magic(&iph6->saddr,
|
|
|
|
&iph6->daddr, tcphdrlen, iph_proto, 0);
|
|
|
|
|
|
|
|
/* Setup SKB fields for checksum offload */
|
|
|
|
skb_partial_csum_set(skb, iphlen,
|
|
|
|
offsetof(struct tcphdr, check));
|
|
|
|
skb_reset_network_header(skb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
static int ibmveth_poll(struct napi_struct *napi, int budget)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-09-03 18:29:30 +00:00
|
|
|
struct ibmveth_adapter *adapter =
|
|
|
|
container_of(napi, struct ibmveth_adapter, napi);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
int frames_processed = 0;
|
|
|
|
unsigned long lpar_rc;
|
2016-12-08 22:40:03 +00:00
|
|
|
u16 mss = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-03-15 01:03:50 +00:00
|
|
|
while (frames_processed < budget) {
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
if (!ibmveth_rxq_pending_buffer(adapter))
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-07 01:21:41 +00:00
|
|
|
smp_rmb();
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
if (!ibmveth_rxq_buffer_valid(adapter)) {
|
|
|
|
wmb(); /* suggested by larson1 */
|
|
|
|
adapter->rx_invalid_buffer++;
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "recycling invalid buffer\n");
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
ibmveth_rxq_recycle_buffer(adapter);
|
|
|
|
} else {
|
2010-09-03 18:28:25 +00:00
|
|
|
struct sk_buff *skb, *new_skb;
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
int length = ibmveth_rxq_frame_length(adapter);
|
|
|
|
int offset = ibmveth_rxq_frame_offset(adapter);
|
2007-09-15 20:36:07 +00:00
|
|
|
int csum_good = ibmveth_rxq_csum_good(adapter);
|
2016-12-08 22:40:03 +00:00
|
|
|
int lrg_pkt = ibmveth_rxq_large_packet(adapter);
|
2007-09-15 20:36:07 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
skb = ibmveth_rxq_get_buffer(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-12-08 22:40:03 +00:00
|
|
|
/* if the large packet bit is set in the rx queue
|
|
|
|
* descriptor, the mss will be written by PHYP eight
|
|
|
|
* bytes from the start of the rx buffer, which is
|
|
|
|
* skb->data at this stage
|
|
|
|
*/
|
|
|
|
if (lrg_pkt) {
|
|
|
|
__be64 *rxmss = (__be64 *)(skb->data + 8);
|
|
|
|
|
|
|
|
mss = (u16)be64_to_cpu(*rxmss);
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:28:25 +00:00
|
|
|
new_skb = NULL;
|
|
|
|
if (length < rx_copybreak)
|
|
|
|
new_skb = netdev_alloc_skb(netdev, length);
|
|
|
|
|
|
|
|
if (new_skb) {
|
|
|
|
skb_copy_to_linear_data(new_skb,
|
|
|
|
skb->data + offset,
|
|
|
|
length);
|
2010-09-03 18:28:41 +00:00
|
|
|
if (rx_flush)
|
|
|
|
ibmveth_flush_buffer(skb->data,
|
|
|
|
length + offset);
|
2011-08-25 00:56:15 +00:00
|
|
|
if (!ibmveth_rxq_recycle_buffer(adapter))
|
|
|
|
kfree_skb(skb);
|
2010-09-03 18:28:25 +00:00
|
|
|
skb = new_skb;
|
|
|
|
} else {
|
|
|
|
ibmveth_rxq_harvest_buffer(adapter);
|
|
|
|
skb_reserve(skb, offset);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
skb_put(skb, length);
|
|
|
|
skb->protocol = eth_type_trans(skb, netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-04-29 21:25:47 +00:00
|
|
|
if (csum_good) {
|
2010-09-03 18:28:25 +00:00
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
ibmveth_rx_csum_helper(skb, adapter);
|
2015-04-29 21:25:47 +00:00
|
|
|
}
|
2010-09-03 18:28:25 +00:00
|
|
|
|
2016-12-08 22:40:03 +00:00
|
|
|
if (length > netdev->mtu + ETH_HLEN) {
|
|
|
|
ibmveth_rx_mss_helper(skb, mss, lrg_pkt);
|
|
|
|
adapter->rx_large_packets++;
|
|
|
|
}
|
|
|
|
|
2015-04-29 21:25:46 +00:00
|
|
|
napi_gro_receive(napi, skb); /* send it up */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-04 00:41:50 +00:00
|
|
|
netdev->stats.rx_packets++;
|
|
|
|
netdev->stats.rx_bytes += length;
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
frames_processed++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-03-15 01:03:50 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-26 16:47:08 +00:00
|
|
|
ibmveth_replenish_task(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
if (frames_processed < budget) {
|
2017-01-30 16:22:01 +00:00
|
|
|
napi_complete_done(napi, frames_processed);
|
2015-03-10 02:15:39 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
/* We think we are done - reenable interrupts,
|
|
|
|
* then check once more to make sure we are done.
|
|
|
|
*/
|
|
|
|
lpar_rc = h_vio_signal(adapter->vdev->unit_address,
|
|
|
|
VIO_IRQ_ENABLE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(lpar_rc != H_SUCCESS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
if (ibmveth_rxq_pending_buffer(adapter) &&
|
2009-01-20 00:43:59 +00:00
|
|
|
napi_reschedule(napi)) {
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
lpar_rc = h_vio_signal(adapter->vdev->unit_address,
|
|
|
|
VIO_IRQ_DISABLE);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
return frames_processed;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
|
2006-05-24 05:31:14 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = dev_instance;
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
2009-01-20 00:43:59 +00:00
|
|
|
if (napi_schedule_prep(&adapter->napi)) {
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
lpar_rc = h_vio_signal(adapter->vdev->unit_address,
|
|
|
|
VIO_IRQ_DISABLE);
|
2010-09-03 18:29:41 +00:00
|
|
|
BUG_ON(lpar_rc != H_SUCCESS);
|
2009-01-20 00:43:59 +00:00
|
|
|
__napi_schedule(&adapter->napi);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_set_multicast_list(struct net_device *netdev)
|
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
2010-02-08 04:30:35 +00:00
|
|
|
if ((netdev->flags & IFF_PROMISC) ||
|
|
|
|
(netdev_mc_count(netdev) > adapter->mcastFilterSize)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastEnableRecv |
|
|
|
|
IbmVethMcastDisableFiltering,
|
|
|
|
0);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "h_multicast_ctrl rc=%ld when "
|
|
|
|
"entering promisc mode\n", lpar_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
} else {
|
2010-04-01 21:22:57 +00:00
|
|
|
struct netdev_hw_addr *ha;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* clear the filter table & disable filtering */
|
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastEnableRecv |
|
|
|
|
IbmVethMcastDisableFiltering |
|
|
|
|
IbmVethMcastClearFilterTable,
|
|
|
|
0);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "h_multicast_ctrl rc=%ld when "
|
|
|
|
"attempting to clear filter table\n",
|
|
|
|
lpar_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
/* add the addresses to the filter table */
|
2010-04-01 21:22:57 +00:00
|
|
|
netdev_for_each_mc_addr(ha, netdev) {
|
2010-09-03 18:29:30 +00:00
|
|
|
/* add the multicast address to the filter table */
|
2014-03-05 03:51:37 +00:00
|
|
|
u64 mcast_addr;
|
|
|
|
mcast_addr = ibmveth_encode_mac_addr(ha->addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastAddFilter,
|
|
|
|
mcast_addr);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "h_multicast_ctrl rc=%ld "
|
|
|
|
"when adding an entry to the filter "
|
|
|
|
"table\n", lpar_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* re-enable filtering */
|
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastEnableFiltering,
|
|
|
|
0);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (lpar_rc != H_SUCCESS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "h_multicast_ctrl rc=%ld when "
|
|
|
|
"enabling filtering\n", lpar_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(dev);
|
2008-07-23 18:34:52 +00:00
|
|
|
struct vio_dev *viodev = adapter->vdev;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH;
|
2010-08-17 09:15:45 +00:00
|
|
|
int i, rc;
|
|
|
|
int need_restart = 0;
|
2005-10-26 16:47:01 +00:00
|
|
|
|
2010-09-03 18:29:25 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
|
2015-04-23 04:43:05 +00:00
|
|
|
if (new_mtu_oh <= adapter->rx_buff_pool[i].buff_size)
|
2007-06-08 19:05:17 +00:00
|
|
|
break;
|
|
|
|
|
2010-09-03 18:29:25 +00:00
|
|
|
if (i == IBMVETH_NUM_BUFF_POOLS)
|
2007-06-08 19:05:17 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-07-23 18:34:23 +00:00
|
|
|
/* Deactivate all the buffer pools so that the next loop can activate
|
|
|
|
only the buffer pools necessary to hold the new MTU */
|
2010-08-17 09:15:45 +00:00
|
|
|
if (netif_running(adapter->netdev)) {
|
|
|
|
need_restart = 1;
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(adapter->netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
}
|
2008-07-23 18:34:23 +00:00
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
/* Look for an active buffer pool that can hold the new MTU */
|
2010-09-03 18:29:30 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
|
2008-07-23 18:34:23 +00:00
|
|
|
adapter->rx_buff_pool[i].active = 1;
|
2007-06-08 19:05:17 +00:00
|
|
|
|
2015-04-23 04:43:05 +00:00
|
|
|
if (new_mtu_oh <= adapter->rx_buff_pool[i].buff_size) {
|
2008-07-23 18:34:52 +00:00
|
|
|
dev->mtu = new_mtu;
|
|
|
|
vio_cmo_set_dev_desired(viodev,
|
|
|
|
ibmveth_get_desired_dma
|
|
|
|
(viodev));
|
2010-08-17 09:15:45 +00:00
|
|
|
if (need_restart) {
|
|
|
|
return ibmveth_open(adapter->netdev);
|
|
|
|
}
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
return 0;
|
2005-10-26 16:47:01 +00:00
|
|
|
}
|
|
|
|
}
|
2010-08-17 09:15:45 +00:00
|
|
|
|
|
|
|
if (need_restart && (rc = ibmveth_open(adapter->netdev)))
|
|
|
|
return rc;
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-03 17:24:28 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
static void ibmveth_poll_controller(struct net_device *dev)
|
|
|
|
{
|
2008-11-13 07:38:14 +00:00
|
|
|
ibmveth_replenish_task(netdev_priv(dev));
|
2006-10-10 21:33:30 +00:00
|
|
|
ibmveth_interrupt(dev->irq, dev);
|
2006-10-03 17:24:28 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-07-23 18:34:52 +00:00
|
|
|
/**
|
|
|
|
* ibmveth_get_desired_dma - Calculate IO memory desired by the driver
|
|
|
|
*
|
|
|
|
* @vdev: struct vio_dev for the device whose desired IO mem is to be returned
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* Number of bytes of IO data the driver will need to perform well.
|
|
|
|
*/
|
|
|
|
static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = dev_get_drvdata(&vdev->dev);
|
|
|
|
struct ibmveth_adapter *adapter;
|
2013-12-09 07:17:03 +00:00
|
|
|
struct iommu_table *tbl;
|
2008-07-23 18:34:52 +00:00
|
|
|
unsigned long ret;
|
|
|
|
int i;
|
|
|
|
int rxqentries = 1;
|
|
|
|
|
2013-12-09 07:17:03 +00:00
|
|
|
tbl = get_iommu_table_base(&vdev->dev);
|
|
|
|
|
2008-07-23 18:34:52 +00:00
|
|
|
/* netdev inits at probe time along with the structures we need below*/
|
|
|
|
if (netdev == NULL)
|
2013-12-09 07:17:03 +00:00
|
|
|
return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT, tbl);
|
2008-07-23 18:34:52 +00:00
|
|
|
|
|
|
|
adapter = netdev_priv(netdev);
|
|
|
|
|
|
|
|
ret = IBMVETH_BUFF_LIST_SIZE + IBMVETH_FILT_LIST_SIZE;
|
2013-12-09 07:17:03 +00:00
|
|
|
ret += IOMMU_PAGE_ALIGN(netdev->mtu, tbl);
|
2008-07-23 18:34:52 +00:00
|
|
|
|
2010-09-03 18:29:25 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
|
2008-07-23 18:34:52 +00:00
|
|
|
/* add the size of the active receive buffers */
|
|
|
|
if (adapter->rx_buff_pool[i].active)
|
|
|
|
ret +=
|
|
|
|
adapter->rx_buff_pool[i].size *
|
|
|
|
IOMMU_PAGE_ALIGN(adapter->rx_buff_pool[i].
|
2013-12-09 07:17:03 +00:00
|
|
|
buff_size, tbl);
|
2008-07-23 18:34:52 +00:00
|
|
|
rxqentries += adapter->rx_buff_pool[i].size;
|
|
|
|
}
|
|
|
|
/* add the size of the receive queue entries */
|
2013-12-09 07:17:03 +00:00
|
|
|
ret += IOMMU_PAGE_ALIGN(
|
|
|
|
rxqentries * sizeof(struct ibmveth_rx_q_entry), tbl);
|
2008-07-23 18:34:52 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-03-02 17:56:12 +00:00
|
|
|
static int ibmveth_set_mac_addr(struct net_device *dev, void *p)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(dev);
|
|
|
|
struct sockaddr *addr = p;
|
|
|
|
u64 mac_address;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (!is_valid_ether_addr(addr->sa_data))
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
mac_address = ibmveth_encode_mac_addr(addr->sa_data);
|
|
|
|
rc = h_change_logical_lan_mac(adapter->vdev->unit_address, mac_address);
|
|
|
|
if (rc) {
|
|
|
|
netdev_err(adapter->netdev, "h_change_logical_lan_mac failed with rc=%d\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
ether_addr_copy(dev->dev_addr, addr->sa_data);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-15 12:52:39 +00:00
|
|
|
static const struct net_device_ops ibmveth_netdev_ops = {
|
|
|
|
.ndo_open = ibmveth_open,
|
|
|
|
.ndo_stop = ibmveth_close,
|
|
|
|
.ndo_start_xmit = ibmveth_start_xmit,
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = ibmveth_set_multicast_list,
|
2009-04-15 12:52:39 +00:00
|
|
|
.ndo_do_ioctl = ibmveth_ioctl,
|
|
|
|
.ndo_change_mtu = ibmveth_change_mtu,
|
2011-04-19 02:14:25 +00:00
|
|
|
.ndo_fix_features = ibmveth_fix_features,
|
|
|
|
.ndo_set_features = ibmveth_set_features,
|
2009-04-15 12:52:39 +00:00
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2015-03-02 17:56:12 +00:00
|
|
|
.ndo_set_mac_address = ibmveth_set_mac_addr,
|
2009-04-15 12:52:39 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = ibmveth_poll_controller,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2012-12-06 14:30:56 +00:00
|
|
|
static int ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-05-03 17:19:01 +00:00
|
|
|
int rc, i, mac_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev;
|
2007-08-06 21:44:03 +00:00
|
|
|
struct ibmveth_adapter *adapter;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char *mac_addr_p;
|
|
|
|
unsigned int *mcastFilterSize_p;
|
2015-07-14 15:51:51 +00:00
|
|
|
long ret;
|
|
|
|
unsigned long ret_attr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
dev_dbg(&dev->dev, "entering ibmveth_probe for UA 0x%x\n",
|
|
|
|
dev->unit_address);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
mac_addr_p = (unsigned char *)vio_get_attribute(dev, VETH_MAC_ADDR,
|
2013-05-03 17:19:01 +00:00
|
|
|
&mac_len);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!mac_addr_p) {
|
2010-09-03 18:29:19 +00:00
|
|
|
dev_err(&dev->dev, "Can't find VETH_MAC_ADDR attribute\n");
|
2010-09-03 18:29:36 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-05-03 17:19:01 +00:00
|
|
|
/* Workaround for old/broken pHyp */
|
|
|
|
if (mac_len == 8)
|
|
|
|
mac_addr_p += 2;
|
|
|
|
else if (mac_len != 6) {
|
|
|
|
dev_err(&dev->dev, "VETH_MAC_ADDR attribute wrong len %d\n",
|
|
|
|
mac_len);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
mcastFilterSize_p = (unsigned int *)vio_get_attribute(dev,
|
2007-04-17 03:12:55 +00:00
|
|
|
VETH_MCAST_FILTER_SIZE, NULL);
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!mcastFilterSize_p) {
|
2010-09-03 18:29:19 +00:00
|
|
|
dev_err(&dev->dev, "Can't find VETH_MCAST_FILTER_SIZE "
|
|
|
|
"attribute\n");
|
2010-09-03 18:29:36 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-05-24 05:31:14 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
netdev = alloc_etherdev(sizeof(struct ibmveth_adapter));
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (!netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-11-13 07:38:14 +00:00
|
|
|
adapter = netdev_priv(netdev);
|
2009-05-05 04:33:19 +00:00
|
|
|
dev_set_drvdata(&dev->dev, netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
adapter->vdev = dev;
|
|
|
|
adapter->netdev = netdev;
|
2010-09-03 18:29:30 +00:00
|
|
|
adapter->mcastFilterSize = *mcastFilterSize_p;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
adapter->pool_config = 0;
|
2006-05-24 05:31:14 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
netdev->irq = dev->irq;
|
2009-04-15 12:52:39 +00:00
|
|
|
netdev->netdev_ops = &ibmveth_netdev_ops;
|
|
|
|
netdev->ethtool_ops = &netdev_ethtool_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
SET_NETDEV_DEV(netdev, &dev->dev);
|
2017-01-24 06:28:41 +00:00
|
|
|
netdev->hw_features = NETIF_F_SG;
|
|
|
|
if (vio_get_attribute(dev, "ibm,illan-options", NULL) != NULL) {
|
|
|
|
netdev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
|
|
|
|
NETIF_F_RXCSUM;
|
|
|
|
}
|
2015-07-14 15:51:51 +00:00
|
|
|
|
2011-04-19 02:14:25 +00:00
|
|
|
netdev->features |= netdev->hw_features;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-07-14 15:51:51 +00:00
|
|
|
ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
|
|
|
|
|
|
|
|
/* If running older firmware, TSO should not be enabled by default */
|
|
|
|
if (ret == H_SUCCESS && (ret_attr & IBMVETH_ILLAN_LRG_SND_SUPPORT) &&
|
|
|
|
!old_large_send) {
|
|
|
|
netdev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6;
|
|
|
|
netdev->features |= netdev->hw_features;
|
|
|
|
} else {
|
|
|
|
netdev->hw_features |= NETIF_F_TSO;
|
|
|
|
}
|
2015-04-29 21:25:45 +00:00
|
|
|
|
ibmveth: Support to enable LSO/CSO for Trunk VEA.
Current largesend and checksum offload feature in ibmveth driver,
- Source VM sends the TCP packets with ip_summed field set as
CHECKSUM_PARTIAL and TCP pseudo header checksum is placed in
checksum field
- CHECKSUM_PARTIAL flag in SKB will enable ibmveth driver to mark
"no checksum" and "checksum good" bits in transmit buffer descriptor
before the packet is delivered to pseries PowerVM Hypervisor
- If ibmveth has largesend capability enabled, transmit buffer descriptors
are market accordingly before packet is delivered to Hypervisor
(along with mss value for packets with length > MSS)
- Destination VM's ibmveth driver receives the packet with "checksum good"
bit set and so, SKB's ip_summed field is set with CHECKSUM_UNNECESSARY
- If "largesend" bit was on, mss value is copied from receive descriptor
into SKB's gso_size and other flags are appropriately set for
packets > MSS size
- The packet is now successfully delivered up the stack in destination VM
The offloads described above works fine for TCP communication among VMs in
the same pseries server ( VM A <=> PowerVM Hypervisor <=> VM B )
We are now enabling support for OVS in pseries PowerVM environment. One of
our requirements is to have ibmveth driver configured in "Trunk" mode, when
they are used with OVS. This is because, PowerVM Hypervisor will no more
bridge the packets between VMs, instead the packets are delivered to
IO Server which hosts OVS to bridge them between VMs or to external
networks (flow shown below),
VM A <=> PowerVM Hypervisor <=> IO Server(OVS) <=> PowerVM Hypervisor
<=> VM B
In "IO server" the packet is received by inbound Trunk ibmveth and then
delivered to OVS, which is then bridged to outbound Trunk ibmveth (shown
below),
Inbound Trunk ibmveth <=> OVS <=> Outbound Trunk ibmveth
In this model, we hit the following issues which impacted the VM
communication performance,
- Issue 1: ibmveth doesn't support largesend and checksum offload features
when configured as "Trunk". Driver has explicit checks to prevent
enabling these offloads.
- Issue 2: SYN packet drops seen at destination VM. When the packet
originates, it has CHECKSUM_PARTIAL flag set and as it gets delivered to
IO server's inbound Trunk ibmveth, on validating "checksum good" bits
in ibmveth receive routine, SKB's ip_summed field is set with
CHECKSUM_UNNECESSARY flag. This packet is then bridged by OVS (or Linux
Bridge) and delivered to outbound Trunk ibmveth. At this point the
outbound ibmveth transmit routine will not set "no checksum" and
"checksum good" bits in transmit buffer descriptor, as it does so only
when the ip_summed field is CHECKSUM_PARTIAL. When this packet gets
delivered to destination VM, TCP layer receives the packet with checksum
value of 0 and with no checksum related flags in ip_summed field. This
leads to packet drops. So, TCP connections never goes through fine.
- Issue 3: First packet of a TCP connection will be dropped, if there is
no OVS flow cached in datapath. OVS while trying to identify the flow,
computes the checksum. The computed checksum will be invalid at the
receiving end, as ibmveth transmit routine zeroes out the pseudo
checksum value in the packet. This leads to packet drop.
- Issue 4: ibmveth driver doesn't have support for SKB's with frag_list.
When Physical NIC has GRO enabled and when OVS bridges these packets,
OVS vport send code will end up calling dev_queue_xmit, which in turn
calls validate_xmit_skb.
In validate_xmit_skb routine, the larger packets will get segmented into
MSS sized segments, if SKB has a frag_list and if the driver to which
they are delivered to doesn't support NETIF_F_FRAGLIST feature.
This patch addresses the above four issues, thereby enabling end to end
largesend and checksum offload support for better performance.
- Fix for Issue 1 : Remove checks which prevent enabling TCP largesend and
checksum offloads.
- Fix for Issue 2 : When ibmveth receives a packet with "checksum good"
bit set and if its configured in Trunk mode, set appropriate SKB fields
using skb_partial_csum_set (ip_summed field is set with
CHECKSUM_PARTIAL)
- Fix for Issue 3: Recompute the pseudo header checksum before sending the
SKB up the stack.
- Fix for Issue 4: Linearize the SKBs with frag_list. Though we end up
allocating buffers and copying data, this fix gives
upto 4X throughput increase.
Note: All these fixes need to be dropped together as fixing just one of
them will lead to other issues immediately (especially for Issues 1,2 & 3).
Signed-off-by: Sivakumar Krishnasamy <ksiva@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-19 09:30:38 +00:00
|
|
|
adapter->is_active_trunk = false;
|
|
|
|
if (ret == H_SUCCESS && (ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK)) {
|
|
|
|
adapter->is_active_trunk = true;
|
|
|
|
netdev->hw_features |= NETIF_F_FRAGLIST;
|
|
|
|
netdev->features |= NETIF_F_FRAGLIST;
|
|
|
|
}
|
|
|
|
|
ethernet: use net core MTU range checking in more drivers
Somehow, I missed a healthy number of ethernet drivers in the last pass.
Most of these drivers either were in need of an updated max_mtu to make
jumbo frames possible to enable again. In a few cases, also setting a
different min_mtu to match previous lower bounds. There are also a few
drivers that had no upper bounds checking, so they're getting a brand new
ETH_MAX_MTU that is identical to IP_MAX_MTU, but accessible by includes
all ethernet and ethernet-like drivers all have already.
acenic:
- min_mtu = 0, max_mtu = 9000
amazon/ena:
- min_mtu = 128, max_mtu = adapter->max_mtu
amd/xgbe:
- min_mtu = 0, max_mtu = 9000
sb1250:
- min_mtu = 0, max_mtu = 1518
cxgb3:
- min_mtu = 81, max_mtu = 65535
cxgb4:
- min_mtu = 81, max_mtu = 9600
cxgb4vf:
- min_mtu = 81, max_mtu = 65535
benet:
- min_mtu = 256, max_mtu = 9000
ibmveth:
- min_mtu = 68, max_mtu = 65535
ibmvnic:
- min_mtu = adapter->min_mtu, max_mtu = adapter->max_mtu
- remove now redundant ibmvnic_change_mtu
jme:
- min_mtu = 1280, max_mtu = 9202
mv643xx_eth:
- min_mtu = 64, max_mtu = 9500
mlxsw:
- min_mtu = 0, max_mtu = 65535
- Basically bypassing the core checks, and instead relying on dynamic
checks in the respective switch drivers' ndo_change_mtu functions
ns83820:
- min_mtu = 0
- remove redundant ns83820_change_mtu, only checked for mtu > 1500
netxen:
- min_mtu = 0, max_mtu = 8000 (P2), max_mtu = 9600 (P3)
qlge:
- min_mtu = 1500, max_mtu = 9000
- driver only supports setting mtu to 1500 or 9000, so the core check only
rules out < 1500 and > 9000, qlge_change_mtu still needs to check that
the value is 1500 or 9000
qualcomm/emac:
- min_mtu = 46, max_mtu = 9194
xilinx_axienet:
- min_mtu = 64, max_mtu = 9000
Fixes: 61e84623ace3 ("net: centralize net_device min/max MTU checking")
CC: netdev@vger.kernel.org
CC: Jes Sorensen <jes@trained-monkey.org>
CC: Netanel Belgazal <netanel@annapurnalabs.com>
CC: Tom Lendacky <thomas.lendacky@amd.com>
CC: Santosh Raspatur <santosh@chelsio.com>
CC: Hariprasad S <hariprasad@chelsio.com>
CC: Sathya Perla <sathya.perla@broadcom.com>
CC: Ajit Khaparde <ajit.khaparde@broadcom.com>
CC: Sriharsha Basavapatna <sriharsha.basavapatna@broadcom.com>
CC: Somnath Kotur <somnath.kotur@broadcom.com>
CC: Thomas Falcon <tlfalcon@linux.vnet.ibm.com>
CC: John Allen <jallen@linux.vnet.ibm.com>
CC: Guo-Fu Tseng <cooldavid@cooldavid.org>
CC: Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
CC: Jiri Pirko <jiri@mellanox.com>
CC: Ido Schimmel <idosch@mellanox.com>
CC: Manish Chopra <manish.chopra@qlogic.com>
CC: Sony Chacko <sony.chacko@qlogic.com>
CC: Rajesh Borundia <rajesh.borundia@qlogic.com>
CC: Timur Tabi <timur@codeaurora.org>
CC: Anirudha Sarangi <anirudh@xilinx.com>
CC: John Linn <John.Linn@xilinx.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 17:55:16 +00:00
|
|
|
netdev->min_mtu = IBMVETH_MIN_MTU;
|
2016-10-24 12:42:26 +00:00
|
|
|
netdev->max_mtu = ETH_MAX_MTU;
|
ethernet: use net core MTU range checking in more drivers
Somehow, I missed a healthy number of ethernet drivers in the last pass.
Most of these drivers either were in need of an updated max_mtu to make
jumbo frames possible to enable again. In a few cases, also setting a
different min_mtu to match previous lower bounds. There are also a few
drivers that had no upper bounds checking, so they're getting a brand new
ETH_MAX_MTU that is identical to IP_MAX_MTU, but accessible by includes
all ethernet and ethernet-like drivers all have already.
acenic:
- min_mtu = 0, max_mtu = 9000
amazon/ena:
- min_mtu = 128, max_mtu = adapter->max_mtu
amd/xgbe:
- min_mtu = 0, max_mtu = 9000
sb1250:
- min_mtu = 0, max_mtu = 1518
cxgb3:
- min_mtu = 81, max_mtu = 65535
cxgb4:
- min_mtu = 81, max_mtu = 9600
cxgb4vf:
- min_mtu = 81, max_mtu = 65535
benet:
- min_mtu = 256, max_mtu = 9000
ibmveth:
- min_mtu = 68, max_mtu = 65535
ibmvnic:
- min_mtu = adapter->min_mtu, max_mtu = adapter->max_mtu
- remove now redundant ibmvnic_change_mtu
jme:
- min_mtu = 1280, max_mtu = 9202
mv643xx_eth:
- min_mtu = 64, max_mtu = 9500
mlxsw:
- min_mtu = 0, max_mtu = 65535
- Basically bypassing the core checks, and instead relying on dynamic
checks in the respective switch drivers' ndo_change_mtu functions
ns83820:
- min_mtu = 0
- remove redundant ns83820_change_mtu, only checked for mtu > 1500
netxen:
- min_mtu = 0, max_mtu = 8000 (P2), max_mtu = 9600 (P3)
qlge:
- min_mtu = 1500, max_mtu = 9000
- driver only supports setting mtu to 1500 or 9000, so the core check only
rules out < 1500 and > 9000, qlge_change_mtu still needs to check that
the value is 1500 or 9000
qualcomm/emac:
- min_mtu = 46, max_mtu = 9194
xilinx_axienet:
- min_mtu = 64, max_mtu = 9000
Fixes: 61e84623ace3 ("net: centralize net_device min/max MTU checking")
CC: netdev@vger.kernel.org
CC: Jes Sorensen <jes@trained-monkey.org>
CC: Netanel Belgazal <netanel@annapurnalabs.com>
CC: Tom Lendacky <thomas.lendacky@amd.com>
CC: Santosh Raspatur <santosh@chelsio.com>
CC: Hariprasad S <hariprasad@chelsio.com>
CC: Sathya Perla <sathya.perla@broadcom.com>
CC: Ajit Khaparde <ajit.khaparde@broadcom.com>
CC: Sriharsha Basavapatna <sriharsha.basavapatna@broadcom.com>
CC: Somnath Kotur <somnath.kotur@broadcom.com>
CC: Thomas Falcon <tlfalcon@linux.vnet.ibm.com>
CC: John Allen <jallen@linux.vnet.ibm.com>
CC: Guo-Fu Tseng <cooldavid@cooldavid.org>
CC: Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
CC: Jiri Pirko <jiri@mellanox.com>
CC: Ido Schimmel <idosch@mellanox.com>
CC: Manish Chopra <manish.chopra@qlogic.com>
CC: Sony Chacko <sony.chacko@qlogic.com>
CC: Rajesh Borundia <rajesh.borundia@qlogic.com>
CC: Timur Tabi <timur@codeaurora.org>
CC: Anirudha Sarangi <anirudh@xilinx.com>
CC: John Linn <John.Linn@xilinx.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 17:55:16 +00:00
|
|
|
|
2014-03-05 03:51:37 +00:00
|
|
|
memcpy(netdev->dev_addr, mac_addr_p, ETH_ALEN);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-04-29 21:25:44 +00:00
|
|
|
if (firmware_has_feature(FW_FEATURE_CMO))
|
|
|
|
memcpy(pool_count, pool_count_cmo, sizeof(pool_count));
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
struct kobject *kobj = &adapter->rx_buff_pool[i].kobj;
|
2007-12-17 19:54:39 +00:00
|
|
|
int error;
|
|
|
|
|
2006-05-24 05:31:14 +00:00
|
|
|
ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i,
|
|
|
|
pool_count[i], pool_size[i],
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
pool_active[i]);
|
2007-12-17 19:54:39 +00:00
|
|
|
error = kobject_init_and_add(kobj, &ktype_veth_pool,
|
|
|
|
&dev->dev.kobj, "pool%d", i);
|
|
|
|
if (!error)
|
|
|
|
kobject_uevent(kobj, KOBJ_ADD);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "adapter @ 0x%p\n", adapter);
|
|
|
|
netdev_dbg(netdev, "registering netdev...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-04-28 01:59:15 +00:00
|
|
|
ibmveth_set_features(netdev, netdev->features);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
rc = register_netdev(netdev);
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
if (rc) {
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "failed to register netdev rc=%d\n", rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
free_netdev(netdev);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:14 +00:00
|
|
|
netdev_dbg(netdev, "registered\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-03 14:23:12 +00:00
|
|
|
static int ibmveth_remove(struct vio_dev *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-05-05 04:33:19 +00:00
|
|
|
struct net_device *netdev = dev_get_drvdata(&dev->dev);
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
int i;
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
|
2007-12-20 16:13:05 +00:00
|
|
|
kobject_put(&adapter->rx_buff_pool[i].kobj);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unregister_netdev(netdev);
|
|
|
|
|
|
|
|
free_netdev(netdev);
|
2008-07-23 18:34:52 +00:00
|
|
|
dev_set_drvdata(&dev->dev, NULL);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
static struct attribute veth_active_attr;
|
|
|
|
static struct attribute veth_num_attr;
|
|
|
|
static struct attribute veth_size_attr;
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
static ssize_t veth_pool_show(struct kobject *kobj,
|
|
|
|
struct attribute *attr, char *buf)
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
{
|
2006-05-24 05:31:14 +00:00
|
|
|
struct ibmveth_buff_pool *pool = container_of(kobj,
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
struct ibmveth_buff_pool,
|
|
|
|
kobj);
|
|
|
|
|
|
|
|
if (attr == &veth_active_attr)
|
|
|
|
return sprintf(buf, "%d\n", pool->active);
|
|
|
|
else if (attr == &veth_num_attr)
|
|
|
|
return sprintf(buf, "%d\n", pool->size);
|
|
|
|
else if (attr == &veth_size_attr)
|
|
|
|
return sprintf(buf, "%d\n", pool->buff_size);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
static ssize_t veth_pool_store(struct kobject *kobj, struct attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
{
|
2006-05-24 05:31:14 +00:00
|
|
|
struct ibmveth_buff_pool *pool = container_of(kobj,
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
struct ibmveth_buff_pool,
|
|
|
|
kobj);
|
2009-05-05 04:33:19 +00:00
|
|
|
struct net_device *netdev = dev_get_drvdata(
|
|
|
|
container_of(kobj->parent, struct device, kobj));
|
2008-11-13 07:38:14 +00:00
|
|
|
struct ibmveth_adapter *adapter = netdev_priv(netdev);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
long value = simple_strtol(buf, NULL, 10);
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
if (attr == &veth_active_attr) {
|
|
|
|
if (value && !pool->active) {
|
2007-06-08 19:05:16 +00:00
|
|
|
if (netif_running(netdev)) {
|
2010-09-03 18:29:30 +00:00
|
|
|
if (ibmveth_alloc_buffer_pool(pool)) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev,
|
|
|
|
"unable to alloc pool\n");
|
2007-06-08 19:05:16 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
pool->active = 1;
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2007-06-08 19:05:16 +00:00
|
|
|
pool->active = 1;
|
2010-09-03 18:29:30 +00:00
|
|
|
}
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
} else if (!value && pool->active) {
|
|
|
|
int mtu = netdev->mtu + IBMVETH_BUFF_OH;
|
|
|
|
int i;
|
|
|
|
/* Make sure there is a buffer pool with buffers that
|
|
|
|
can hold a packet of the size of the MTU */
|
2010-09-03 18:29:25 +00:00
|
|
|
for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
if (pool == &adapter->rx_buff_pool[i])
|
|
|
|
continue;
|
|
|
|
if (!adapter->rx_buff_pool[i].active)
|
|
|
|
continue;
|
2007-08-03 03:55:19 +00:00
|
|
|
if (mtu <= adapter->rx_buff_pool[i].buff_size)
|
|
|
|
break;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
}
|
2007-08-03 03:55:19 +00:00
|
|
|
|
2010-09-03 18:29:25 +00:00
|
|
|
if (i == IBMVETH_NUM_BUFF_POOLS) {
|
2010-09-03 18:29:19 +00:00
|
|
|
netdev_err(netdev, "no active pool >= MTU\n");
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
return -EPERM;
|
|
|
|
}
|
2007-08-03 03:55:19 +00:00
|
|
|
|
|
|
|
if (netif_running(netdev)) {
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
2008-07-23 18:34:23 +00:00
|
|
|
pool->active = 0;
|
2007-08-03 03:55:19 +00:00
|
|
|
adapter->pool_config = 0;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
|
|
|
}
|
2008-07-23 18:34:23 +00:00
|
|
|
pool->active = 0;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
}
|
|
|
|
} else if (attr == &veth_num_attr) {
|
2010-09-03 18:29:30 +00:00
|
|
|
if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT) {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
return -EINVAL;
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2007-06-08 19:05:16 +00:00
|
|
|
if (netif_running(netdev)) {
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
pool->size = value;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2007-06-08 19:05:16 +00:00
|
|
|
pool->size = value;
|
2010-09-03 18:29:30 +00:00
|
|
|
}
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
}
|
|
|
|
} else if (attr == &veth_size_attr) {
|
2010-09-03 18:29:30 +00:00
|
|
|
if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE) {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
return -EINVAL;
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2007-06-08 19:05:16 +00:00
|
|
|
if (netif_running(netdev)) {
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
pool->buff_size = value;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
2010-09-03 18:29:30 +00:00
|
|
|
} else {
|
2007-06-08 19:05:16 +00:00
|
|
|
pool->buff_size = value;
|
2010-09-03 18:29:30 +00:00
|
|
|
}
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* kick the interrupt handler to allocate/deallocate pools */
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
ibmveth_interrupt(netdev->irq, netdev);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
#define ATTR(_name, _mode) \
|
|
|
|
struct attribute veth_##_name##_attr = { \
|
|
|
|
.name = __stringify(_name), .mode = _mode, \
|
|
|
|
};
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
|
|
|
|
static ATTR(active, 0644);
|
|
|
|
static ATTR(num, 0644);
|
|
|
|
static ATTR(size, 0644);
|
|
|
|
|
2010-09-03 18:29:30 +00:00
|
|
|
static struct attribute *veth_pool_attrs[] = {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
&veth_active_attr,
|
|
|
|
&veth_num_attr,
|
|
|
|
&veth_size_attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2010-01-19 01:58:23 +00:00
|
|
|
static const struct sysfs_ops veth_pool_ops = {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
.show = veth_pool_show,
|
|
|
|
.store = veth_pool_store,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kobj_type ktype_veth_pool = {
|
|
|
|
.release = NULL,
|
|
|
|
.sysfs_ops = &veth_pool_ops,
|
|
|
|
.default_attrs = veth_pool_attrs,
|
|
|
|
};
|
|
|
|
|
2010-05-07 08:56:08 +00:00
|
|
|
static int ibmveth_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = dev_get_drvdata(dev);
|
|
|
|
ibmveth_interrupt(netdev->irq, netdev);
|
|
|
|
return 0;
|
|
|
|
}
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 16:19:59 +00:00
|
|
|
|
2017-08-17 13:22:53 +00:00
|
|
|
static const struct vio_device_id ibmveth_device_table[] = {
|
2005-04-16 22:20:36 +00:00
|
|
|
{ "network", "IBM,l-lan"},
|
2005-08-17 06:42:59 +00:00
|
|
|
{ "", "" }
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(vio, ibmveth_device_table);
|
|
|
|
|
2017-06-29 05:44:50 +00:00
|
|
|
static const struct dev_pm_ops ibmveth_pm_ops = {
|
2010-05-07 08:56:08 +00:00
|
|
|
.resume = ibmveth_resume
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct vio_driver ibmveth_driver = {
|
2005-10-24 04:53:21 +00:00
|
|
|
.id_table = ibmveth_device_table,
|
|
|
|
.probe = ibmveth_probe,
|
|
|
|
.remove = ibmveth_remove,
|
2008-07-23 18:34:52 +00:00
|
|
|
.get_desired_dma = ibmveth_get_desired_dma,
|
2012-03-26 19:06:30 +00:00
|
|
|
.name = ibmveth_driver_name,
|
|
|
|
.pm = &ibmveth_pm_ops,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init ibmveth_module_init(void)
|
|
|
|
{
|
2010-09-03 18:29:19 +00:00
|
|
|
printk(KERN_DEBUG "%s: %s %s\n", ibmveth_driver_name,
|
|
|
|
ibmveth_driver_string, ibmveth_driver_version);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return vio_register_driver(&ibmveth_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit ibmveth_module_exit(void)
|
|
|
|
{
|
|
|
|
vio_unregister_driver(&ibmveth_driver);
|
2006-05-24 05:31:14 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
module_init(ibmveth_module_init);
|
|
|
|
module_exit(ibmveth_module_exit);
|