Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 56728748 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net 

Pull networking update from David Miller:

 1) Fix RX sequence number handling in mwifiex, from Stone Piao.

 2) Netfilter ipset mis-compares device names, fix from Florian
    Westphal.

 3) Fix route leak in ipv6 IPVS, from Eric Dumazet.

 4) NFS fixes.  Several buffer overflows in NCI layer from Dan
    Rosenberg, and release sock OOPS'er fix from Eric Dumazet.

 5) Fix WEP handling ath9k, we started using a bit the chip provides to
    indicate undecrypted packets but that bit turns out to be unreliable
    in certain configurations.  Fix from Felix Fietkau.

 6) Fix Kconfig dependency bug in wlcore, from Randy Dunlap.

 7) New USB IDs for rtlwifi driver from Larry Finger.

 8) Fix crashes in qmi_wwan usbnet driver when disconnecting, from Bjørn
    Mork.

 9) Gianfar driver programs coalescing settings properly in single queue
    mode, but does not do so in multi-queue mode.  Fix from Claudiu
    Manoil.

10) Missing module.h include in davinci_cpdma.c, from Daniel Mack.

11) Need dummy handler for IPSET_CMD_NONE otherwise we crash in ipset if
    we get this via nfnetlink, fix from Tomasz Bursztyka.

12) Missing RCU unlock in nfnetlink error path, also from Tomasz.

13) Fix divide by zero in igbvf when the user tries to set an RX
    coalescing value of 0 usecs, from Mitch A Williams.

14) We can process SCTP sacks for the wrong transport, oops.  Fix from
    Neil Horman.

15) Remove hw IP payload checksumming from e1000e driver.  This has zery
    value in our stack, and turning it on creates a very unintuitive
    restriction for users when using jumbo MTUs.

    Specifically, when IP payload checksums are on you cannot use both
    receive hashing offload and jumbo MTU.  Fix from Bruce Allan.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (27 commits)
  e1000e: remove use of IP payload checksum
  sctp: be more restrictive in transport selection on bundled sacks
  igbvf: fix divide by zero
  netfilter: nfnetlink: fix missing rcu_read_unlock in nfnetlink_rcv_msg
  netfilter: ipset: fix crash if IPSET_CMD_NONE command is sent
  davinci_cpdma: include linux/module.h
  gianfar: Fix RXICr/TXICr programming for multi-queue mode
  net: Downgrade CAP_SYS_MODULE deprecated message from error to warning.
  net: qmi_wwan: fix Oops while disconnecting
  mwifiex: fix memory leak associated with IE manamgement
  ath9k: fix panic caused by returning a descriptor we have queued for reuse
  mac80211: correct behaviour on unrecognised action frames
  ath9k: enable serialize_regmode for non-PCIE AR9287
  rtlwifi: rtl8192cu: New USB IDs
  NFC: Return from rawsock_release when sk is NULL
  iwlwifi: fix activating inactive stations
  wlcore: drop INET dependency
  ath9k: fix dynamic WEP related regression
  NFC: Prevent multiple buffer overflows in NCI
  netfilter: update location of my trees
  ...
parents dab058fd 2e1706f2

MAINTAINERS

+2 −2
Original line number Diff line number Diff line
@@ -4654,8 +4654,8 @@ L: netfilter@vger.kernel.org 
L:	coreteam@netfilter.org

W:	http://www.netfilter.org/

W:	http://www.iptables.org/

T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-2.6.git

T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next-2.6.git

T:	git git://1984.lsi.us.es/nf

T:	git git://1984.lsi.us.es/nf-next

S:	Supported

F:	include/linux/netfilter*

F:	include/linux/netfilter/

drivers/net/ethernet/freescale/gianfar.c

+4 −6
Original line number Diff line number Diff line
@@ -1804,21 +1804,19 @@ void gfar_configure_coalescing(struct gfar_private *priv, 
	if (priv->mode == MQ_MG_MODE) {

		baddr = &regs->txic0;

		for_each_set_bit(i, &tx_mask, priv->num_tx_queues) {

			if (likely(priv->tx_queue[i]->txcoalescing)) {

			gfar_write(baddr + i, 0);

			if (likely(priv->tx_queue[i]->txcoalescing))

				gfar_write(baddr + i, priv->tx_queue[i]->txic);

		}

		}



		baddr = &regs->rxic0;

		for_each_set_bit(i, &rx_mask, priv->num_rx_queues) {

			if (likely(priv->rx_queue[i]->rxcoalescing)) {

			gfar_write(baddr + i, 0);

			if (likely(priv->rx_queue[i]->rxcoalescing))

				gfar_write(baddr + i, priv->rx_queue[i]->rxic);

		}

	}

}

}



static int register_grp_irqs(struct gfar_priv_grp *grp)

{

drivers/net/ethernet/intel/e1000e/defines.h

+1 −0
Original line number Diff line number Diff line
@@ -103,6 +103,7 @@ 
#define E1000_RXD_ERR_SEQ       0x04    /* Sequence Error */

#define E1000_RXD_ERR_CXE       0x10    /* Carrier Extension Error */

#define E1000_RXD_ERR_TCPE      0x20    /* TCP/UDP Checksum Error */

#define E1000_RXD_ERR_IPE       0x40    /* IP Checksum Error */

#define E1000_RXD_ERR_RXE       0x80    /* Rx Data Error */

#define E1000_RXD_SPC_VLAN_MASK 0x0FFF  /* VLAN ID is in lower 12 bits */

drivers/net/ethernet/intel/e1000e/netdev.c

+14 −61
Original line number Diff line number Diff line
@@ -496,7 +496,7 @@ static void e1000_receive_skb(struct e1000_adapter *adapter, 
 * @sk_buff: socket buffer with received data

 **/

static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,

			      __le16 csum, struct sk_buff *skb)

			      struct sk_buff *skb)

{

	u16 status = (u16)status_err;

	u8 errors = (u8)(status_err >> 24);
@@ -511,8 +511,8 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err, 
	if (status & E1000_RXD_STAT_IXSM)

		return;



	/* TCP/UDP checksum error bit is set */

	if (errors & E1000_RXD_ERR_TCPE) {

	/* TCP/UDP checksum error bit or IP checksum error bit is set */

	if (errors & (E1000_RXD_ERR_TCPE | E1000_RXD_ERR_IPE)) {

		/* let the stack verify checksum errors */

		adapter->hw_csum_err++;

		return;
@@ -523,19 +523,7 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err, 
		return;



	/* It must be a TCP or UDP packet with a valid checksum */

	if (status & E1000_RXD_STAT_TCPCS) {

		/* TCP checksum is good */

	skb->ip_summed = CHECKSUM_UNNECESSARY;

	} else {

		/*

		 * IP fragment with UDP payload

		 * Hardware complements the payload checksum, so we undo it

		 * and then put the value in host order for further stack use.

		 */

		__sum16 sum = (__force __sum16)swab16((__force u16)csum);

		skb->csum = csum_unfold(~sum);

		skb->ip_summed = CHECKSUM_COMPLETE;

	}

	adapter->hw_csum_good++;

}
@@ -954,8 +942,7 @@ static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done, 
		skb_put(skb, length);



		/* Receive Checksum Offload */

		e1000_rx_checksum(adapter, staterr,

				  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);

		e1000_rx_checksum(adapter, staterr, skb);



		e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
@@ -1341,8 +1328,7 @@ copydone: 
		total_rx_bytes += skb->len;

		total_rx_packets++;



		e1000_rx_checksum(adapter, staterr,

				  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);

		e1000_rx_checksum(adapter, staterr, skb);



		e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
@@ -1512,9 +1498,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done, 
			}

		}



		/* Receive Checksum Offload XXX recompute due to CRC strip? */

		e1000_rx_checksum(adapter, staterr,

				  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);

		/* Receive Checksum Offload */

		e1000_rx_checksum(adapter, staterr, skb);



		e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
@@ -3098,19 +3083,10 @@ static void e1000_configure_rx(struct e1000_adapter *adapter) 


	/* Enable Receive Checksum Offload for TCP and UDP */

	rxcsum = er32(RXCSUM);

	if (adapter->netdev->features & NETIF_F_RXCSUM) {

	if (adapter->netdev->features & NETIF_F_RXCSUM)

		rxcsum |= E1000_RXCSUM_TUOFL;



		/*

		 * IPv4 payload checksum for UDP fragments must be

		 * used in conjunction with packet-split.

		 */

		if (adapter->rx_ps_pages)

			rxcsum |= E1000_RXCSUM_IPPCSE;

	} else {

	else

		rxcsum &= ~E1000_RXCSUM_TUOFL;

		/* no need to clear IPPCSE as it defaults to 0 */

	}

	ew32(RXCSUM, rxcsum);



	if (adapter->hw.mac.type == e1000_pch2lan) {
@@ -5241,24 +5217,12 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu) 
	int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;



	/* Jumbo frame support */

	if (max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) {

		if (!(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {

	if ((max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) &&

	    !(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {

		e_err("Jumbo Frames not supported.\n");

		return -EINVAL;

	}



		/*

		 * IP payload checksum (enabled with jumbos/packet-split when

		 * Rx checksum is enabled) and generation of RSS hash is

		 * mutually exclusive in the hardware.

		 */

		if ((netdev->features & NETIF_F_RXCSUM) &&

		    (netdev->features & NETIF_F_RXHASH)) {

			e_err("Jumbo frames cannot be enabled when both receive checksum offload and receive hashing are enabled.  Disable one of the receive offload features before enabling jumbos.\n");

			return -EINVAL;

		}

	}



	/* Supported frame sizes */

	if ((new_mtu < ETH_ZLEN + ETH_FCS_LEN + VLAN_HLEN) ||

	    (max_frame > adapter->max_hw_frame_size)) {
@@ -6030,17 +5994,6 @@ static int e1000_set_features(struct net_device *netdev, 
			 NETIF_F_RXALL)))

		return 0;



	/*

	 * IP payload checksum (enabled with jumbos/packet-split when Rx

	 * checksum is enabled) and generation of RSS hash is mutually

	 * exclusive in the hardware.

	 */

	if (adapter->rx_ps_pages &&

	    (features & NETIF_F_RXCSUM) && (features & NETIF_F_RXHASH)) {

		e_err("Enabling both receive checksum offload and receive hashing is not possible with jumbo frames.  Disable jumbos or enable only one of the receive offload features.\n");

		return -EINVAL;

	}



	if (changed & NETIF_F_RXFCS) {

		if (features & NETIF_F_RXFCS) {

			adapter->flags2 &= ~FLAG2_CRC_STRIPPING;

drivers/net/ethernet/intel/igbvf/ethtool.c

+18 −11
Original line number Diff line number Diff line
@@ -357,21 +357,28 @@ static int igbvf_set_coalesce(struct net_device *netdev, 
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	struct e1000_hw *hw = &adapter->hw;



	if ((ec->rx_coalesce_usecs > IGBVF_MAX_ITR_USECS) ||

	    ((ec->rx_coalesce_usecs > 3) &&

	     (ec->rx_coalesce_usecs < IGBVF_MIN_ITR_USECS)) ||

	    (ec->rx_coalesce_usecs == 2))

		return -EINVAL;



	/* convert to rate of irq's per second */

	if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) {

	if ((ec->rx_coalesce_usecs >= IGBVF_MIN_ITR_USECS) &&

	     (ec->rx_coalesce_usecs <= IGBVF_MAX_ITR_USECS)) {

		adapter->current_itr = ec->rx_coalesce_usecs << 2;

		adapter->requested_itr = 1000000000 /

					(adapter->current_itr * 256);

	} else if ((ec->rx_coalesce_usecs == 3) ||

		   (ec->rx_coalesce_usecs == 2)) {

		adapter->current_itr = IGBVF_START_ITR;

		adapter->requested_itr = ec->rx_coalesce_usecs;

	} else {

		adapter->current_itr = ec->rx_coalesce_usecs << 2;

	} else if (ec->rx_coalesce_usecs == 0) {

		/*

		 * The user's desire is to turn off interrupt throttling

		 * altogether, but due to HW limitations, we can't do that.

		 * Instead we set a very small value in EITR, which would

		 * allow ~967k interrupts per second, but allow the adapter's

		 * internal clocking to still function properly.

		 */

		adapter->current_itr = 4;

		adapter->requested_itr = 1000000000 /

					(adapter->current_itr * 256);

	}

	} else

		return -EINVAL;



	writel(adapter->current_itr,

	       hw->hw_addr + adapter->rx_ring->itr_register);