tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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

Pull networking fixes from David Miller:

1) Use after free and new device IDs in bluetooth from Andre Guedes,
Yevgeniy Melnichuk, Gustavo Padovan, and Henrik Rydberg.

2) Fix crashes with short packet lengths and VLAN in pktgen, from
Nishank Trivedi.

3) mISDN calls flush_work_sync() with locks held, fix from Karsten
Keil.

4) Packet scheduler gred parameters are reported to userspace
improperly scaled, and WRED idling is not performed correctly. All
from David Ward.

5) Fix TCP socket refcount problem in ipv6, from Julian Anastasov.

6) ibmveth device has RX queue alignment requirements which are not
being explicitly met resulting in sporadic failures, fix from
Santiago Leon.

7) Netfilter needs to take care when interpreting sockets attached to
socket buffers, they could be time-wait minisockets. Fix from Eric
Dumazet.

8) sock_edemux() has the same issue as netfilter did in #7 above, fix
from Eric Dumazet.

9) Avoid infinite loops in CBQ scheduler with some configurations, from
Eric Dumazet.

10) Deal with "Reflection scan: an Off-Path Attack on TCP", from Jozsef
Kadlecsik.

11) SCTP overcharges socket for TX packets, fix from Thomas Graf.

12) CODEL packet scheduler should not reset it's state every time it
builds a new flow, fix from Eric Dumazet.

13) Fix memory leak in nl80211, from Wei Yongjun.

14) NETROM doesn't check skb_copy_datagram_iovec() return values, from
Alan Cox.

15) l2tp ethernet was using sizeof(ETH_HLEN) instead of plain ETH_HLEN,
oops. From Eric Dumazet.

16) Fix selection of ath9k chips on which PA linearization and AM2PM
predistoration are used, from Felix Fietkau.

17) Flow steering settings in mlx4 driver need to be validated properly,
from Hadar Hen Zion.

18) bnx2x doesn't show the correct link duplex setting, from Yaniv
Rosner.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (75 commits)
pktgen: fix crash with vlan and packet size less than 46
bnx2x: Add missing afex code
bnx2x: fix registers dumped
bnx2x: correct advertisement of pause capabilities
bnx2x: display the correct duplex value
bnx2x: prevent timeouts when using PFC
bnx2x: fix stats copying logic
bnx2x: Avoid sending multiple statistics queries
net: qmi_wwan: call subdriver with control intf only
net_sched: gred: actually perform idling in WRED mode
net_sched: gred: fix qave reporting via netlink
net_sched: gred: eliminate redundant DP prio comparisons
net_sched: gred: correct comment about qavg calculation in RIO mode
mISDN: Fix wrong usage of flush_work_sync while holding locks
netfilter: log: Fix log-level processing
net-sched: sch_cbq: avoid infinite loop
net: qmi_wwan: fix Gobi device probing for un2430
net: fix net/core/sock.c build error
ixp4xx_hss: fix build failure due to missing linux/module.h inclusion
caif: move the dereference below the NULL test
...

Linus Torvalds a1362d50 4bca55d3

+808 -342
+2
drivers/bluetooth/ath3k.c
··· 86 86 87 87 /* Atheros AR5BBU22 with sflash firmware */ 88 88 { USB_DEVICE(0x0489, 0xE03C) }, 89 + { USB_DEVICE(0x0489, 0xE036) }, 89 90 90 91 { } /* Terminating entry */ 91 92 }; ··· 110 109 111 110 /* Atheros AR5BBU22 with sflash firmware */ 112 111 { USB_DEVICE(0x0489, 0xE03C), .driver_info = BTUSB_ATH3012 }, 112 + { USB_DEVICE(0x0489, 0xE036), .driver_info = BTUSB_ATH3012 }, 113 113 114 114 { } /* Terminating entry */ 115 115 };
+7 -5
drivers/bluetooth/btusb.c
··· 52 52 /* Generic Bluetooth USB device */ 53 53 { USB_DEVICE_INFO(0xe0, 0x01, 0x01) }, 54 54 55 + /* Apple-specific (Broadcom) devices */ 56 + { USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) }, 57 + 55 58 /* Broadcom SoftSailing reporting vendor specific */ 56 59 { USB_DEVICE(0x0a5c, 0x21e1) }, 57 60 ··· 97 94 98 95 /* Broadcom BCM20702A0 */ 99 96 { USB_DEVICE(0x0489, 0xe042) }, 100 - { USB_DEVICE(0x0a5c, 0x21e3) }, 101 - { USB_DEVICE(0x0a5c, 0x21e6) }, 102 - { USB_DEVICE(0x0a5c, 0x21e8) }, 103 - { USB_DEVICE(0x0a5c, 0x21f3) }, 104 - { USB_DEVICE(0x0a5c, 0x21f4) }, 105 97 { USB_DEVICE(0x413c, 0x8197) }, 106 98 107 99 /* Foxconn - Hon Hai */ 108 100 { USB_DEVICE(0x0489, 0xe033) }, 101 + 102 + /*Broadcom devices with vendor specific id */ 103 + { USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) }, 109 104 110 105 { } /* Terminating entry */ 111 106 }; ··· 142 141 143 142 /* Atheros AR5BBU12 with sflash firmware */ 144 143 { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 }, 144 + { USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 }, 145 145 146 146 /* Broadcom BCM2035 */ 147 147 { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
+2 -1
drivers/isdn/hardware/mISDN/avmfritz.c
··· 857 857 switch (cmd) { 858 858 case CLOSE_CHANNEL: 859 859 test_and_clear_bit(FLG_OPEN, &bch->Flags); 860 + cancel_work_sync(&bch->workq); 860 861 spin_lock_irqsave(&fc->lock, flags); 861 - mISDN_freebchannel(bch); 862 + mISDN_clear_bchannel(bch); 862 863 modehdlc(bch, ISDN_P_NONE); 863 864 spin_unlock_irqrestore(&fc->lock, flags); 864 865 ch->protocol = ISDN_P_NONE;
+2
drivers/isdn/hardware/mISDN/hfcmulti.c
··· 5059 5059 printk(KERN_INFO 5060 5060 "HFC-E1 #%d has overlapping B-channels on fragment #%d\n", 5061 5061 E1_cnt + 1, pt); 5062 + kfree(hc); 5062 5063 return -EINVAL; 5063 5064 } 5064 5065 maskcheck |= hc->bmask[pt]; ··· 5087 5086 if ((poll >> 1) > sizeof(hc->silence_data)) { 5088 5087 printk(KERN_ERR "HFCMULTI error: silence_data too small, " 5089 5088 "please fix\n"); 5089 + kfree(hc); 5090 5090 return -EINVAL; 5091 5091 } 5092 5092 for (i = 0; i < (poll >> 1); i++)
+2 -1
drivers/isdn/hardware/mISDN/mISDNipac.c
··· 1406 1406 switch (cmd) { 1407 1407 case CLOSE_CHANNEL: 1408 1408 test_and_clear_bit(FLG_OPEN, &bch->Flags); 1409 + cancel_work_sync(&bch->workq); 1409 1410 spin_lock_irqsave(hx->ip->hwlock, flags); 1410 - mISDN_freebchannel(bch); 1411 + mISDN_clear_bchannel(bch); 1411 1412 hscx_mode(hx, ISDN_P_NONE); 1412 1413 spin_unlock_irqrestore(hx->ip->hwlock, flags); 1413 1414 ch->protocol = ISDN_P_NONE;
+2 -1
drivers/isdn/hardware/mISDN/mISDNisar.c
··· 1588 1588 switch (cmd) { 1589 1589 case CLOSE_CHANNEL: 1590 1590 test_and_clear_bit(FLG_OPEN, &bch->Flags); 1591 + cancel_work_sync(&bch->workq); 1591 1592 spin_lock_irqsave(ich->is->hwlock, flags); 1592 - mISDN_freebchannel(bch); 1593 + mISDN_clear_bchannel(bch); 1593 1594 modeisar(ich, ISDN_P_NONE); 1594 1595 spin_unlock_irqrestore(ich->is->hwlock, flags); 1595 1596 ch->protocol = ISDN_P_NONE;
+2 -1
drivers/isdn/hardware/mISDN/netjet.c
··· 812 812 switch (cmd) { 813 813 case CLOSE_CHANNEL: 814 814 test_and_clear_bit(FLG_OPEN, &bch->Flags); 815 + cancel_work_sync(&bch->workq); 815 816 spin_lock_irqsave(&card->lock, flags); 816 - mISDN_freebchannel(bch); 817 + mISDN_clear_bchannel(bch); 817 818 mode_tiger(bc, ISDN_P_NONE); 818 819 spin_unlock_irqrestore(&card->lock, flags); 819 820 ch->protocol = ISDN_P_NONE;
+2 -1
drivers/isdn/hardware/mISDN/w6692.c
··· 1054 1054 switch (cmd) { 1055 1055 case CLOSE_CHANNEL: 1056 1056 test_and_clear_bit(FLG_OPEN, &bch->Flags); 1057 + cancel_work_sync(&bch->workq); 1057 1058 spin_lock_irqsave(&card->lock, flags); 1058 - mISDN_freebchannel(bch); 1059 + mISDN_clear_bchannel(bch); 1059 1060 w6692_mode(bc, ISDN_P_NONE); 1060 1061 spin_unlock_irqrestore(&card->lock, flags); 1061 1062 ch->protocol = ISDN_P_NONE;
+4 -5
drivers/isdn/mISDN/hwchannel.c
··· 148 148 ch->next_minlen = ch->init_minlen; 149 149 ch->maxlen = ch->init_maxlen; 150 150 ch->next_maxlen = ch->init_maxlen; 151 + skb_queue_purge(&ch->rqueue); 152 + ch->rcount = 0; 151 153 } 152 154 EXPORT_SYMBOL(mISDN_clear_bchannel); 153 155 154 - int 156 + void 155 157 mISDN_freebchannel(struct bchannel *ch) 156 158 { 159 + cancel_work_sync(&ch->workq); 157 160 mISDN_clear_bchannel(ch); 158 - skb_queue_purge(&ch->rqueue); 159 - ch->rcount = 0; 160 - flush_work_sync(&ch->workq); 161 - return 0; 162 161 } 163 162 EXPORT_SYMBOL(mISDN_freebchannel); 164 163
+10 -1
drivers/net/can/mcp251x.c
··· 83 83 #define INSTRUCTION_LOAD_TXB(n) (0x40 + 2 * (n)) 84 84 #define INSTRUCTION_READ_RXB(n) (((n) == 0) ? 0x90 : 0x94) 85 85 #define INSTRUCTION_RESET 0xC0 86 + #define RTS_TXB0 0x01 87 + #define RTS_TXB1 0x02 88 + #define RTS_TXB2 0x04 89 + #define INSTRUCTION_RTS(n) (0x80 | ((n) & 0x07)) 90 + 86 91 87 92 /* MPC251x registers */ 88 93 #define CANSTAT 0x0e ··· 402 397 static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame, 403 398 int tx_buf_idx) 404 399 { 400 + struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev); 405 401 u32 sid, eid, exide, rtr; 406 402 u8 buf[SPI_TRANSFER_BUF_LEN]; 407 403 ··· 424 418 buf[TXBDLC_OFF] = (rtr << DLC_RTR_SHIFT) | frame->can_dlc; 425 419 memcpy(buf + TXBDAT_OFF, frame->data, frame->can_dlc); 426 420 mcp251x_hw_tx_frame(spi, buf, frame->can_dlc, tx_buf_idx); 427 - mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx), TXBCTRL_TXREQ); 421 + 422 + /* use INSTRUCTION_RTS, to avoid "repeated frame problem" */ 423 + priv->spi_tx_buf[0] = INSTRUCTION_RTS(1 << tx_buf_idx); 424 + mcp251x_spi_trans(priv->spi, 1); 428 425 } 429 426 430 427 static void mcp251x_hw_rx_frame(struct spi_device *spi, u8 *buf,
+5 -6
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
··· 710 710 prod = txdata->tx_bd_prod; 711 711 cons = txdata->tx_bd_cons; 712 712 713 - /* NUM_TX_RINGS = number of "next-page" entries 714 - It will be used as a threshold */ 715 - used = SUB_S16(prod, cons) + (s16)NUM_TX_RINGS; 713 + used = SUB_S16(prod, cons); 716 714 717 715 #ifdef BNX2X_STOP_ON_ERROR 718 716 WARN_ON(used < 0); 719 - WARN_ON(used > bp->tx_ring_size); 720 - WARN_ON((bp->tx_ring_size - used) > MAX_TX_AVAIL); 717 + WARN_ON(used > txdata->tx_ring_size); 718 + WARN_ON((txdata->tx_ring_size - used) > MAX_TX_AVAIL); 721 719 #endif 722 720 723 - return (s16)(bp->tx_ring_size) - used; 721 + return (s16)(txdata->tx_ring_size) - used; 724 722 } 725 723 726 724 static inline int bnx2x_tx_queue_has_work(struct bnx2x_fp_txdata *txdata) ··· 1086 1088 txdata->txq_index = txq_index; 1087 1089 txdata->tx_cons_sb = tx_cons_sb; 1088 1090 txdata->parent_fp = fp; 1091 + txdata->tx_ring_size = IS_FCOE_FP(fp) ? MAX_TX_AVAIL : bp->tx_ring_size; 1089 1092 1090 1093 DP(NETIF_MSG_IFUP, "created tx data cid %d, txq %d\n", 1091 1094 txdata->cid, txdata->txq_index);
+8 -17
drivers/net/ethernet/broadcom/bnx2x/bnx2x_dump.h
··· 401 401 { 0x70000, 8, RI_ALL_ONLINE }, 402 402 { 0x70020, 8184, RI_ALL_OFFLINE }, 403 403 { 0x78000, 8192, RI_E3E3B0_OFFLINE }, 404 - { 0x85000, 3, RI_ALL_ONLINE }, 405 - { 0x8501c, 7, RI_ALL_ONLINE }, 406 - { 0x85048, 1, RI_ALL_ONLINE }, 407 - { 0x85200, 32, RI_ALL_ONLINE }, 408 - { 0xb0000, 16384, RI_E1H_ONLINE }, 404 + { 0x85000, 3, RI_ALL_OFFLINE }, 405 + { 0x8501c, 7, RI_ALL_OFFLINE }, 406 + { 0x85048, 1, RI_ALL_OFFLINE }, 407 + { 0x85200, 32, RI_ALL_OFFLINE }, 408 + { 0xb0000, 16384, RI_E1H_OFFLINE }, 409 409 { 0xc1000, 7, RI_ALL_ONLINE }, 410 410 { 0xc103c, 2, RI_E2E3E3B0_ONLINE }, 411 411 { 0xc1800, 2, RI_ALL_ONLINE }, ··· 581 581 { 0x140188, 3, RI_E1E1HE2E3_ONLINE }, 582 582 { 0x140194, 13, RI_ALL_ONLINE }, 583 583 { 0x140200, 6, RI_E1E1HE2E3_ONLINE }, 584 - { 0x140220, 4, RI_E2E3_ONLINE }, 585 - { 0x140240, 4, RI_E2E3_ONLINE }, 586 584 { 0x140260, 4, RI_E2E3_ONLINE }, 587 585 { 0x140280, 4, RI_E2E3_ONLINE }, 588 - { 0x1402a0, 4, RI_E2E3_ONLINE }, 589 - { 0x1402c0, 4, RI_E2E3_ONLINE }, 590 586 { 0x1402e0, 2, RI_E2E3_ONLINE }, 591 587 { 0x1402e8, 2, RI_E2E3E3B0_ONLINE }, 592 588 { 0x1402f0, 9, RI_E2E3_ONLINE }, 593 589 { 0x140314, 44, RI_E3B0_ONLINE }, 594 - { 0x1403d0, 70, RI_E3B0_ONLINE }, 595 590 { 0x144000, 4, RI_E1E1H_ONLINE }, 596 591 { 0x148000, 4, RI_E1E1H_ONLINE }, 597 592 { 0x14c000, 4, RI_E1E1H_ONLINE }, ··· 699 704 { 0x180398, 1, RI_E2E3E3B0_ONLINE }, 700 705 { 0x1803a0, 5, RI_E2E3E3B0_ONLINE }, 701 706 { 0x1803b4, 2, RI_E3E3B0_ONLINE }, 702 - { 0x180400, 1, RI_ALL_ONLINE }, 703 707 { 0x180404, 255, RI_E1E1H_OFFLINE }, 704 708 { 0x181000, 4, RI_ALL_ONLINE }, 705 709 { 0x181010, 1020, RI_ALL_OFFLINE }, ··· 794 800 { 0x1b905c, 1, RI_E3E3B0_ONLINE }, 795 801 { 0x1b9064, 1, RI_E3B0_ONLINE }, 796 802 { 0x1b9080, 10, RI_E3B0_ONLINE }, 797 - { 0x1b9400, 14, RI_E2E3E3B0_ONLINE }, 798 - { 0x1b943c, 19, RI_E2E3E3B0_ONLINE }, 799 - { 0x1b9490, 10, RI_E2E3E3B0_ONLINE }, 803 + { 0x1b9400, 14, RI_E2E3E3B0_OFFLINE }, 804 + { 0x1b943c, 19, RI_E2E3E3B0_OFFLINE }, 805 + { 0x1b9490, 10, RI_E2E3E3B0_OFFLINE }, 800 806 { 0x1c0000, 2, RI_ALL_ONLINE }, 801 807 { 0x200000, 65, RI_ALL_ONLINE }, 802 808 { 0x20014c, 2, RI_E1HE2E3E3B0_ONLINE }, ··· 808 814 { 0x200398, 1, RI_E2E3E3B0_ONLINE }, 809 815 { 0x2003a0, 1, RI_E2E3E3B0_ONLINE }, 810 816 { 0x2003a8, 2, RI_E2E3E3B0_ONLINE }, 811 - { 0x200400, 1, RI_ALL_ONLINE }, 812 817 { 0x200404, 255, RI_E1E1H_OFFLINE }, 813 818 { 0x202000, 4, RI_ALL_ONLINE }, 814 819 { 0x202010, 2044, RI_ALL_OFFLINE }, ··· 914 921 { 0x280398, 1, RI_E2E3E3B0_ONLINE }, 915 922 { 0x2803a0, 1, RI_E2E3E3B0_ONLINE }, 916 923 { 0x2803a8, 2, RI_E2E3E3B0_ONLINE }, 917 - { 0x280400, 1, RI_ALL_ONLINE }, 918 924 { 0x280404, 255, RI_E1E1H_OFFLINE }, 919 925 { 0x282000, 4, RI_ALL_ONLINE }, 920 926 { 0x282010, 2044, RI_ALL_OFFLINE }, ··· 1023 1031 { 0x300398, 1, RI_E2E3E3B0_ONLINE }, 1024 1032 { 0x3003a0, 1, RI_E2E3E3B0_ONLINE }, 1025 1033 { 0x3003a8, 2, RI_E2E3E3B0_ONLINE }, 1026 - { 0x300400, 1, RI_ALL_ONLINE }, 1027 1034 { 0x300404, 255, RI_E1E1H_OFFLINE }, 1028 1035 { 0x302000, 4, RI_ALL_ONLINE }, 1029 1036 { 0x302010, 2044, RI_ALL_OFFLINE },
+7 -1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
··· 775 775 struct bnx2x *bp = netdev_priv(dev); 776 776 struct dump_hdr dump_hdr = {0}; 777 777 778 - regs->version = 0; 778 + regs->version = 1; 779 779 memset(p, 0, regs->len); 780 780 781 781 if (!netif_running(bp->dev)) ··· 1587 1587 bp->link_params.req_flow_ctrl[cfg_idx] = 1588 1588 BNX2X_FLOW_CTRL_AUTO; 1589 1589 } 1590 + bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_NONE; 1591 + if (epause->rx_pause) 1592 + bp->link_params.req_fc_auto_adv |= BNX2X_FLOW_CTRL_RX; 1593 + 1594 + if (epause->tx_pause) 1595 + bp->link_params.req_fc_auto_adv |= BNX2X_FLOW_CTRL_TX; 1590 1596 } 1591 1597 1592 1598 DP(BNX2X_MSG_ETHTOOL,
+11 -7
drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
··· 2667 2667 return bnx2x_status; 2668 2668 2669 2669 DP(NETIF_MSG_LINK, "About to update PFC in BMAC\n"); 2670 - if (CHIP_IS_E3(bp)) 2671 - bnx2x_update_pfc_xmac(params, vars, 0); 2672 - else { 2670 + 2671 + if (CHIP_IS_E3(bp)) { 2672 + if (vars->mac_type == MAC_TYPE_XMAC) 2673 + bnx2x_update_pfc_xmac(params, vars, 0); 2674 + } else { 2673 2675 val = REG_RD(bp, MISC_REG_RESET_REG_2); 2674 2676 if ((val & 2675 2677 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port)) ··· 5434 5432 switch (speed_mask) { 5435 5433 case GP_STATUS_10M: 5436 5434 vars->line_speed = SPEED_10; 5437 - if (vars->duplex == DUPLEX_FULL) 5435 + if (is_duplex == DUPLEX_FULL) 5438 5436 vars->link_status |= LINK_10TFD; 5439 5437 else 5440 5438 vars->link_status |= LINK_10THD; ··· 5442 5440 5443 5441 case GP_STATUS_100M: 5444 5442 vars->line_speed = SPEED_100; 5445 - if (vars->duplex == DUPLEX_FULL) 5443 + if (is_duplex == DUPLEX_FULL) 5446 5444 vars->link_status |= LINK_100TXFD; 5447 5445 else 5448 5446 vars->link_status |= LINK_100TXHD; ··· 5451 5449 case GP_STATUS_1G: 5452 5450 case GP_STATUS_1G_KX: 5453 5451 vars->line_speed = SPEED_1000; 5454 - if (vars->duplex == DUPLEX_FULL) 5452 + if (is_duplex == DUPLEX_FULL) 5455 5453 vars->link_status |= LINK_1000TFD; 5456 5454 else 5457 5455 vars->link_status |= LINK_1000THD; ··· 5459 5457 5460 5458 case GP_STATUS_2_5G: 5461 5459 vars->line_speed = SPEED_2500; 5462 - if (vars->duplex == DUPLEX_FULL) 5460 + if (is_duplex == DUPLEX_FULL) 5463 5461 vars->link_status |= LINK_2500TFD; 5464 5462 else 5465 5463 vars->link_status |= LINK_2500THD; ··· 5533 5531 5534 5532 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) { 5535 5533 if (SINGLE_MEDIA_DIRECT(params)) { 5534 + vars->duplex = duplex; 5536 5535 bnx2x_flow_ctrl_resolve(phy, params, vars, gp_status); 5537 5536 if (phy->req_line_speed == SPEED_AUTO_NEG) 5538 5537 bnx2x_xgxs_an_resolve(phy, params, vars, ··· 5628 5625 LINK_STATUS_PARALLEL_DETECTION_USED; 5629 5626 } 5630 5627 bnx2x_ext_phy_resolve_fc(phy, params, vars); 5628 + vars->duplex = duplex; 5631 5629 } 5632 5630 } 5633 5631
+16 -5
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
··· 7561 7561 } 7562 7562 7563 7563 rc = bnx2x_config_vlan_mac(bp, &ramrod_param); 7564 - if (rc < 0) 7564 + 7565 + if (rc == -EEXIST) { 7566 + DP(BNX2X_MSG_SP, "Failed to schedule ADD operations: %d\n", rc); 7567 + /* do not treat adding same MAC as error */ 7568 + rc = 0; 7569 + } else if (rc < 0) 7565 7570 BNX2X_ERR("%s MAC failed\n", (set ? "Set" : "Del")); 7571 + 7566 7572 return rc; 7567 7573 } 7568 7574 ··· 10300 10294 dev_info.port_hw_config[port]. 10301 10295 fcoe_wwn_node_name_lower); 10302 10296 } else if (!IS_MF_SD(bp)) { 10303 - u32 cfg = MF_CFG_RD(bp, func_ext_config[func].func_cfg); 10304 - 10305 10297 /* 10306 10298 * Read the WWN info only if the FCoE feature is enabled for 10307 10299 * this function. 10308 10300 */ 10309 - if (cfg & MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD) 10301 + if (BNX2X_MF_EXT_PROTOCOL_FCOE(bp) && !CHIP_IS_E1x(bp)) 10310 10302 bnx2x_get_ext_wwn_info(bp, func); 10311 10303 10312 10304 } else if (IS_MF_FCOE_SD(bp)) ··· 11077 11073 netdev_for_each_uc_addr(ha, dev) { 11078 11074 rc = bnx2x_set_mac_one(bp, bnx2x_uc_addr(ha), mac_obj, true, 11079 11075 BNX2X_UC_LIST_MAC, &ramrod_flags); 11080 - if (rc < 0) { 11076 + if (rc == -EEXIST) { 11077 + DP(BNX2X_MSG_SP, 11078 + "Failed to schedule ADD operations: %d\n", rc); 11079 + /* do not treat adding same MAC as error */ 11080 + rc = 0; 11081 + 11082 + } else if (rc < 0) { 11083 + 11081 11084 BNX2X_ERR("Failed to schedule ADD operations: %d\n", 11082 11085 rc); 11083 11086 return rc;
+10 -5
drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
··· 101 101 if (CHIP_REV_IS_SLOW(bp)) 102 102 return; 103 103 104 + /* Update MCP's statistics if possible */ 105 + if (bp->func_stx) 106 + memcpy(bnx2x_sp(bp, func_stats), &bp->func_stats, 107 + sizeof(bp->func_stats)); 108 + 104 109 /* loader */ 105 110 if (bp->executer_idx) { 106 111 int loader_idx = PMF_DMAE_C(bp); ··· 133 128 134 129 } else if (bp->func_stx) { 135 130 *stats_comp = 0; 136 - memcpy(bnx2x_sp(bp, func_stats), &bp->func_stats, 137 - sizeof(bp->func_stats)); 138 131 bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp)); 139 132 } 140 133 } ··· 1154 1151 if (bp->port.pmf) 1155 1152 bnx2x_hw_stats_update(bp); 1156 1153 1157 - if (bnx2x_storm_stats_update(bp) && (bp->stats_pending++ == 3)) { 1158 - BNX2X_ERR("storm stats were not updated for 3 times\n"); 1159 - bnx2x_panic(); 1154 + if (bnx2x_storm_stats_update(bp)) { 1155 + if (bp->stats_pending++ == 3) { 1156 + BNX2X_ERR("storm stats were not updated for 3 times\n"); 1157 + bnx2x_panic(); 1158 + } 1160 1159 return; 1161 1160 } 1162 1161
+9 -4
drivers/net/ethernet/i825xx/znet.c
··· 139 139 /* Only one can be built-in;-> */ 140 140 static struct net_device *znet_dev; 141 141 142 + #define NETIDBLK_MAGIC "NETIDBLK" 143 + #define NETIDBLK_MAGIC_SIZE 8 144 + 142 145 struct netidblk { 143 - char magic[8]; /* The magic number (string) "NETIDBLK" */ 146 + char magic[NETIDBLK_MAGIC_SIZE]; /* The magic number (string) "NETIDBLK" */ 144 147 unsigned char netid[8]; /* The physical station address */ 145 148 char nettype, globalopt; 146 149 char vendor[8]; /* The machine vendor and product name. */ ··· 376 373 struct znet_private *znet; 377 374 struct net_device *dev; 378 375 char *p; 376 + char *plast = phys_to_virt(0x100000 - NETIDBLK_MAGIC_SIZE); 379 377 int err = -ENOMEM; 380 378 381 379 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */ 382 - for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++) 383 - if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0) 380 + for(p = (char *)phys_to_virt(0xf0000); p <= plast; p++) 381 + if (*p == 'N' && 382 + strncmp(p, NETIDBLK_MAGIC, NETIDBLK_MAGIC_SIZE) == 0) 384 383 break; 385 384 386 - if (p >= (char *)phys_to_virt(0x100000)) { 385 + if (p > plast) { 387 386 if (znet_debug > 1) 388 387 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n"); 389 388 return -ENODEV;
+9 -17
drivers/net/ethernet/ibm/ibmveth.c
··· 472 472 } 473 473 474 474 if (adapter->rx_queue.queue_addr != NULL) { 475 - if (!dma_mapping_error(dev, adapter->rx_queue.queue_dma)) { 476 - dma_unmap_single(dev, 477 - adapter->rx_queue.queue_dma, 478 - adapter->rx_queue.queue_len, 479 - DMA_BIDIRECTIONAL); 480 - adapter->rx_queue.queue_dma = DMA_ERROR_CODE; 481 - } 482 - kfree(adapter->rx_queue.queue_addr); 475 + dma_free_coherent(dev, adapter->rx_queue.queue_len, 476 + adapter->rx_queue.queue_addr, 477 + adapter->rx_queue.queue_dma); 483 478 adapter->rx_queue.queue_addr = NULL; 484 479 } 485 480 ··· 551 556 goto err_out; 552 557 } 553 558 559 + dev = &adapter->vdev->dev; 560 + 554 561 adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) * 555 562 rxq_entries; 556 - adapter->rx_queue.queue_addr = kmalloc(adapter->rx_queue.queue_len, 557 - GFP_KERNEL); 563 + adapter->rx_queue.queue_addr = 564 + dma_alloc_coherent(dev, adapter->rx_queue.queue_len, 565 + &adapter->rx_queue.queue_dma, GFP_KERNEL); 558 566 559 567 if (!adapter->rx_queue.queue_addr) { 560 568 netdev_err(netdev, "unable to allocate rx queue pages\n"); ··· 565 567 goto err_out; 566 568 } 567 569 568 - dev = &adapter->vdev->dev; 569 - 570 570 adapter->buffer_list_dma = dma_map_single(dev, 571 571 adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL); 572 572 adapter->filter_list_dma = dma_map_single(dev, 573 573 adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL); 574 - adapter->rx_queue.queue_dma = dma_map_single(dev, 575 - adapter->rx_queue.queue_addr, 576 - adapter->rx_queue.queue_len, DMA_BIDIRECTIONAL); 577 574 578 575 if ((dma_mapping_error(dev, adapter->buffer_list_dma)) || 579 - (dma_mapping_error(dev, adapter->filter_list_dma)) || 580 - (dma_mapping_error(dev, adapter->rx_queue.queue_dma))) { 576 + (dma_mapping_error(dev, adapter->filter_list_dma))) { 581 577 netdev_err(netdev, "unable to map filter or buffer list " 582 578 "pages\n"); 583 579 rc = -ENOMEM;
+9 -7
drivers/net/ethernet/mellanox/mlx4/main.c
··· 1234 1234 mlx4_info(dev, "non-primary physical function, skipping.\n"); 1235 1235 else 1236 1236 mlx4_err(dev, "QUERY_FW command failed, aborting.\n"); 1237 - goto unmap_bf; 1237 + return err; 1238 1238 } 1239 1239 1240 1240 err = mlx4_load_fw(dev); 1241 1241 if (err) { 1242 1242 mlx4_err(dev, "Failed to start FW, aborting.\n"); 1243 - goto unmap_bf; 1243 + return err; 1244 1244 } 1245 1245 1246 1246 mlx4_cfg.log_pg_sz_m = 1; ··· 1304 1304 err = mlx4_init_slave(dev); 1305 1305 if (err) { 1306 1306 mlx4_err(dev, "Failed to initialize slave\n"); 1307 - goto unmap_bf; 1307 + return err; 1308 1308 } 1309 1309 1310 1310 err = mlx4_slave_cap(dev); ··· 1324 1324 err = mlx4_QUERY_ADAPTER(dev, &adapter); 1325 1325 if (err) { 1326 1326 mlx4_err(dev, "QUERY_ADAPTER command failed, aborting.\n"); 1327 - goto err_close; 1327 + goto unmap_bf; 1328 1328 } 1329 1329 1330 1330 priv->eq_table.inta_pin = adapter.inta_pin; 1331 1331 memcpy(dev->board_id, adapter.board_id, sizeof dev->board_id); 1332 1332 1333 1333 return 0; 1334 + 1335 + unmap_bf: 1336 + unmap_bf_area(dev); 1334 1337 1335 1338 err_close: 1336 1339 mlx4_close_hca(dev); ··· 1347 1344 mlx4_UNMAP_FA(dev); 1348 1345 mlx4_free_icm(dev, priv->fw.fw_icm, 0); 1349 1346 } 1350 - unmap_bf: 1351 - unmap_bf_area(dev); 1352 1347 return err; 1353 1348 } 1354 1349 ··· 1997 1996 } 1998 1997 1999 1998 slave_start: 2000 - if (mlx4_cmd_init(dev)) { 1999 + err = mlx4_cmd_init(dev); 2000 + if (err) { 2001 2001 mlx4_err(dev, "Failed to init command interface, aborting.\n"); 2002 2002 goto err_sriov; 2003 2003 }
+15 -91
drivers/net/ethernet/mellanox/mlx4/mcg.c
··· 137 137 return err; 138 138 } 139 139 140 - static struct mlx4_promisc_qp *get_promisc_qp(struct mlx4_dev *dev, u8 pf_num, 140 + static struct mlx4_promisc_qp *get_promisc_qp(struct mlx4_dev *dev, u8 port, 141 141 enum mlx4_steer_type steer, 142 142 u32 qpn) 143 143 { 144 - struct mlx4_steer *s_steer = &mlx4_priv(dev)->steer[pf_num]; 144 + struct mlx4_steer *s_steer = &mlx4_priv(dev)->steer[port - 1]; 145 145 struct mlx4_promisc_qp *pqp; 146 146 147 147 list_for_each_entry(pqp, &s_steer->promisc_qps[steer], list) { ··· 182 182 /* If the given qpn is also a promisc qp, 183 183 * it should be inserted to duplicates list 184 184 */ 185 - pqp = get_promisc_qp(dev, 0, steer, qpn); 185 + pqp = get_promisc_qp(dev, port, steer, qpn); 186 186 if (pqp) { 187 187 dqp = kmalloc(sizeof *dqp, GFP_KERNEL); 188 188 if (!dqp) { ··· 256 256 257 257 s_steer = &mlx4_priv(dev)->steer[port - 1]; 258 258 259 - pqp = get_promisc_qp(dev, 0, steer, qpn); 259 + pqp = get_promisc_qp(dev, port, steer, qpn); 260 260 if (!pqp) 261 261 return 0; /* nothing to do */ 262 262 ··· 302 302 s_steer = &mlx4_priv(dev)->steer[port - 1]; 303 303 304 304 /* if qp is not promisc, it cannot be duplicated */ 305 - if (!get_promisc_qp(dev, 0, steer, qpn)) 305 + if (!get_promisc_qp(dev, port, steer, qpn)) 306 306 return false; 307 307 308 308 /* The qp is promisc qp so it is a duplicate on this index ··· 352 352 members_count = be32_to_cpu(mgm->members_count) & 0xffffff; 353 353 for (i = 0; i < members_count; i++) { 354 354 qpn = be32_to_cpu(mgm->qp[i]) & MGM_QPN_MASK; 355 - if (!get_promisc_qp(dev, 0, steer, qpn) && qpn != tqpn) { 355 + if (!get_promisc_qp(dev, port, steer, qpn) && qpn != tqpn) { 356 356 /* the qp is not promisc, the entry can't be removed */ 357 357 goto out; 358 358 } ··· 398 398 399 399 mutex_lock(&priv->mcg_table.mutex); 400 400 401 - if (get_promisc_qp(dev, 0, steer, qpn)) { 401 + if (get_promisc_qp(dev, port, steer, qpn)) { 402 402 err = 0; /* Noting to do, already exists */ 403 403 goto out_mutex; 404 404 } ··· 503 503 s_steer = &mlx4_priv(dev)->steer[port - 1]; 504 504 mutex_lock(&priv->mcg_table.mutex); 505 505 506 - pqp = get_promisc_qp(dev, 0, steer, qpn); 506 + pqp = get_promisc_qp(dev, port, steer, qpn); 507 507 if (unlikely(!pqp)) { 508 508 mlx4_warn(dev, "QP %x is not promiscuous QP\n", qpn); 509 509 /* nothing to do */ ··· 650 650 return err; 651 651 } 652 652 653 - struct mlx4_net_trans_rule_hw_ctrl { 654 - __be32 ctrl; 655 - __be32 vf_vep_port; 656 - __be32 qpn; 657 - __be32 reserved; 658 - }; 659 - 660 653 static void trans_rule_ctrl_to_hw(struct mlx4_net_trans_rule *ctrl, 661 654 struct mlx4_net_trans_rule_hw_ctrl *hw) 662 655 { ··· 673 680 hw->qpn = cpu_to_be32(ctrl->qpn); 674 681 } 675 682 676 - struct mlx4_net_trans_rule_hw_ib { 677 - u8 size; 678 - u8 rsvd1; 679 - __be16 id; 680 - u32 rsvd2; 681 - __be32 qpn; 682 - __be32 qpn_mask; 683 - u8 dst_gid[16]; 684 - u8 dst_gid_msk[16]; 685 - } __packed; 686 - 687 - struct mlx4_net_trans_rule_hw_eth { 688 - u8 size; 689 - u8 rsvd; 690 - __be16 id; 691 - u8 rsvd1[6]; 692 - u8 dst_mac[6]; 693 - u16 rsvd2; 694 - u8 dst_mac_msk[6]; 695 - u16 rsvd3; 696 - u8 src_mac[6]; 697 - u16 rsvd4; 698 - u8 src_mac_msk[6]; 699 - u8 rsvd5; 700 - u8 ether_type_enable; 701 - __be16 ether_type; 702 - __be16 vlan_id_msk; 703 - __be16 vlan_id; 704 - } __packed; 705 - 706 - struct mlx4_net_trans_rule_hw_tcp_udp { 707 - u8 size; 708 - u8 rsvd; 709 - __be16 id; 710 - __be16 rsvd1[3]; 711 - __be16 dst_port; 712 - __be16 rsvd2; 713 - __be16 dst_port_msk; 714 - __be16 rsvd3; 715 - __be16 src_port; 716 - __be16 rsvd4; 717 - __be16 src_port_msk; 718 - } __packed; 719 - 720 - struct mlx4_net_trans_rule_hw_ipv4 { 721 - u8 size; 722 - u8 rsvd; 723 - __be16 id; 724 - __be32 rsvd1; 725 - __be32 dst_ip; 726 - __be32 dst_ip_msk; 727 - __be32 src_ip; 728 - __be32 src_ip_msk; 729 - } __packed; 730 - 731 - struct _rule_hw { 732 - union { 733 - struct { 734 - u8 size; 735 - u8 rsvd; 736 - __be16 id; 737 - }; 738 - struct mlx4_net_trans_rule_hw_eth eth; 739 - struct mlx4_net_trans_rule_hw_ib ib; 740 - struct mlx4_net_trans_rule_hw_ipv4 ipv4; 741 - struct mlx4_net_trans_rule_hw_tcp_udp tcp_udp; 742 - }; 683 + const u16 __sw_id_hw[] = { 684 + [MLX4_NET_TRANS_RULE_ID_ETH] = 0xE001, 685 + [MLX4_NET_TRANS_RULE_ID_IB] = 0xE005, 686 + [MLX4_NET_TRANS_RULE_ID_IPV6] = 0xE003, 687 + [MLX4_NET_TRANS_RULE_ID_IPV4] = 0xE002, 688 + [MLX4_NET_TRANS_RULE_ID_TCP] = 0xE004, 689 + [MLX4_NET_TRANS_RULE_ID_UDP] = 0xE006 743 690 }; 744 691 745 692 static int parse_trans_rule(struct mlx4_dev *dev, struct mlx4_spec_list *spec, 746 693 struct _rule_hw *rule_hw) 747 694 { 748 - static const u16 __sw_id_hw[] = { 749 - [MLX4_NET_TRANS_RULE_ID_ETH] = 0xE001, 750 - [MLX4_NET_TRANS_RULE_ID_IB] = 0xE005, 751 - [MLX4_NET_TRANS_RULE_ID_IPV6] = 0xE003, 752 - [MLX4_NET_TRANS_RULE_ID_IPV4] = 0xE002, 753 - [MLX4_NET_TRANS_RULE_ID_TCP] = 0xE004, 754 - [MLX4_NET_TRANS_RULE_ID_UDP] = 0xE006 755 - }; 756 - 757 695 static const size_t __rule_hw_sz[] = { 758 696 [MLX4_NET_TRANS_RULE_ID_ETH] = 759 697 sizeof(struct mlx4_net_trans_rule_hw_eth),
+76
drivers/net/ethernet/mellanox/mlx4/mlx4.h
··· 690 690 struct list_head steer_entries[MLX4_NUM_STEERS]; 691 691 }; 692 692 693 + struct mlx4_net_trans_rule_hw_ctrl { 694 + __be32 ctrl; 695 + __be32 vf_vep_port; 696 + __be32 qpn; 697 + __be32 reserved; 698 + }; 699 + 700 + struct mlx4_net_trans_rule_hw_ib { 701 + u8 size; 702 + u8 rsvd1; 703 + __be16 id; 704 + u32 rsvd2; 705 + __be32 qpn; 706 + __be32 qpn_mask; 707 + u8 dst_gid[16]; 708 + u8 dst_gid_msk[16]; 709 + } __packed; 710 + 711 + struct mlx4_net_trans_rule_hw_eth { 712 + u8 size; 713 + u8 rsvd; 714 + __be16 id; 715 + u8 rsvd1[6]; 716 + u8 dst_mac[6]; 717 + u16 rsvd2; 718 + u8 dst_mac_msk[6]; 719 + u16 rsvd3; 720 + u8 src_mac[6]; 721 + u16 rsvd4; 722 + u8 src_mac_msk[6]; 723 + u8 rsvd5; 724 + u8 ether_type_enable; 725 + __be16 ether_type; 726 + __be16 vlan_id_msk; 727 + __be16 vlan_id; 728 + } __packed; 729 + 730 + struct mlx4_net_trans_rule_hw_tcp_udp { 731 + u8 size; 732 + u8 rsvd; 733 + __be16 id; 734 + __be16 rsvd1[3]; 735 + __be16 dst_port; 736 + __be16 rsvd2; 737 + __be16 dst_port_msk; 738 + __be16 rsvd3; 739 + __be16 src_port; 740 + __be16 rsvd4; 741 + __be16 src_port_msk; 742 + } __packed; 743 + 744 + struct mlx4_net_trans_rule_hw_ipv4 { 745 + u8 size; 746 + u8 rsvd; 747 + __be16 id; 748 + __be32 rsvd1; 749 + __be32 dst_ip; 750 + __be32 dst_ip_msk; 751 + __be32 src_ip; 752 + __be32 src_ip_msk; 753 + } __packed; 754 + 755 + struct _rule_hw { 756 + union { 757 + struct { 758 + u8 size; 759 + u8 rsvd; 760 + __be16 id; 761 + }; 762 + struct mlx4_net_trans_rule_hw_eth eth; 763 + struct mlx4_net_trans_rule_hw_ib ib; 764 + struct mlx4_net_trans_rule_hw_ipv4 ipv4; 765 + struct mlx4_net_trans_rule_hw_tcp_udp tcp_udp; 766 + }; 767 + }; 768 + 693 769 struct mlx4_priv { 694 770 struct mlx4_dev dev; 695 771
+116
drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
··· 42 42 #include <linux/mlx4/cmd.h> 43 43 #include <linux/mlx4/qp.h> 44 44 #include <linux/if_ether.h> 45 + #include <linux/etherdevice.h> 45 46 46 47 #include "mlx4.h" 47 48 #include "fw.h" ··· 2777 2776 return err; 2778 2777 } 2779 2778 2779 + /* 2780 + * MAC validation for Flow Steering rules. 2781 + * VF can attach rules only with a mac address which is assigned to it. 2782 + */ 2783 + static int validate_eth_header_mac(int slave, struct _rule_hw *eth_header, 2784 + struct list_head *rlist) 2785 + { 2786 + struct mac_res *res, *tmp; 2787 + __be64 be_mac; 2788 + 2789 + /* make sure it isn't multicast or broadcast mac*/ 2790 + if (!is_multicast_ether_addr(eth_header->eth.dst_mac) && 2791 + !is_broadcast_ether_addr(eth_header->eth.dst_mac)) { 2792 + list_for_each_entry_safe(res, tmp, rlist, list) { 2793 + be_mac = cpu_to_be64(res->mac << 16); 2794 + if (!memcmp(&be_mac, eth_header->eth.dst_mac, ETH_ALEN)) 2795 + return 0; 2796 + } 2797 + pr_err("MAC %pM doesn't belong to VF %d, Steering rule rejected\n", 2798 + eth_header->eth.dst_mac, slave); 2799 + return -EINVAL; 2800 + } 2801 + return 0; 2802 + } 2803 + 2804 + /* 2805 + * In case of missing eth header, append eth header with a MAC address 2806 + * assigned to the VF. 2807 + */ 2808 + static int add_eth_header(struct mlx4_dev *dev, int slave, 2809 + struct mlx4_cmd_mailbox *inbox, 2810 + struct list_head *rlist, int header_id) 2811 + { 2812 + struct mac_res *res, *tmp; 2813 + u8 port; 2814 + struct mlx4_net_trans_rule_hw_ctrl *ctrl; 2815 + struct mlx4_net_trans_rule_hw_eth *eth_header; 2816 + struct mlx4_net_trans_rule_hw_ipv4 *ip_header; 2817 + struct mlx4_net_trans_rule_hw_tcp_udp *l4_header; 2818 + __be64 be_mac = 0; 2819 + __be64 mac_msk = cpu_to_be64(MLX4_MAC_MASK << 16); 2820 + 2821 + ctrl = (struct mlx4_net_trans_rule_hw_ctrl *)inbox->buf; 2822 + port = be32_to_cpu(ctrl->vf_vep_port) & 0xff; 2823 + eth_header = (struct mlx4_net_trans_rule_hw_eth *)(ctrl + 1); 2824 + 2825 + /* Clear a space in the inbox for eth header */ 2826 + switch (header_id) { 2827 + case MLX4_NET_TRANS_RULE_ID_IPV4: 2828 + ip_header = 2829 + (struct mlx4_net_trans_rule_hw_ipv4 *)(eth_header + 1); 2830 + memmove(ip_header, eth_header, 2831 + sizeof(*ip_header) + sizeof(*l4_header)); 2832 + break; 2833 + case MLX4_NET_TRANS_RULE_ID_TCP: 2834 + case MLX4_NET_TRANS_RULE_ID_UDP: 2835 + l4_header = (struct mlx4_net_trans_rule_hw_tcp_udp *) 2836 + (eth_header + 1); 2837 + memmove(l4_header, eth_header, sizeof(*l4_header)); 2838 + break; 2839 + default: 2840 + return -EINVAL; 2841 + } 2842 + list_for_each_entry_safe(res, tmp, rlist, list) { 2843 + if (port == res->port) { 2844 + be_mac = cpu_to_be64(res->mac << 16); 2845 + break; 2846 + } 2847 + } 2848 + if (!be_mac) { 2849 + pr_err("Failed adding eth header to FS rule, Can't find matching MAC for port %d .\n", 2850 + port); 2851 + return -EINVAL; 2852 + } 2853 + 2854 + memset(eth_header, 0, sizeof(*eth_header)); 2855 + eth_header->size = sizeof(*eth_header) >> 2; 2856 + eth_header->id = cpu_to_be16(__sw_id_hw[MLX4_NET_TRANS_RULE_ID_ETH]); 2857 + memcpy(eth_header->dst_mac, &be_mac, ETH_ALEN); 2858 + memcpy(eth_header->dst_mac_msk, &mac_msk, ETH_ALEN); 2859 + 2860 + return 0; 2861 + 2862 + } 2863 + 2780 2864 int mlx4_QP_FLOW_STEERING_ATTACH_wrapper(struct mlx4_dev *dev, int slave, 2781 2865 struct mlx4_vhcr *vhcr, 2782 2866 struct mlx4_cmd_mailbox *inbox, 2783 2867 struct mlx4_cmd_mailbox *outbox, 2784 2868 struct mlx4_cmd_info *cmd) 2785 2869 { 2870 + 2871 + struct mlx4_priv *priv = mlx4_priv(dev); 2872 + struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker; 2873 + struct list_head *rlist = &tracker->slave_list[slave].res_list[RES_MAC]; 2786 2874 int err; 2875 + struct mlx4_net_trans_rule_hw_ctrl *ctrl; 2876 + struct _rule_hw *rule_header; 2877 + int header_id; 2787 2878 2788 2879 if (dev->caps.steering_mode != 2789 2880 MLX4_STEERING_MODE_DEVICE_MANAGED) 2790 2881 return -EOPNOTSUPP; 2882 + 2883 + ctrl = (struct mlx4_net_trans_rule_hw_ctrl *)inbox->buf; 2884 + rule_header = (struct _rule_hw *)(ctrl + 1); 2885 + header_id = map_hw_to_sw_id(be16_to_cpu(rule_header->id)); 2886 + 2887 + switch (header_id) { 2888 + case MLX4_NET_TRANS_RULE_ID_ETH: 2889 + if (validate_eth_header_mac(slave, rule_header, rlist)) 2890 + return -EINVAL; 2891 + break; 2892 + case MLX4_NET_TRANS_RULE_ID_IPV4: 2893 + case MLX4_NET_TRANS_RULE_ID_TCP: 2894 + case MLX4_NET_TRANS_RULE_ID_UDP: 2895 + pr_warn("Can't attach FS rule without L2 headers, adding L2 header.\n"); 2896 + if (add_eth_header(dev, slave, inbox, rlist, header_id)) 2897 + return -EINVAL; 2898 + vhcr->in_modifier += 2899 + sizeof(struct mlx4_net_trans_rule_hw_eth) >> 2; 2900 + break; 2901 + default: 2902 + pr_err("Corrupted mailbox.\n"); 2903 + return -EINVAL; 2904 + } 2791 2905 2792 2906 err = mlx4_cmd_imm(dev, inbox->dma, &vhcr->out_param, 2793 2907 vhcr->in_modifier, 0,
+1
drivers/net/ethernet/seeq/sgiseeq.c
··· 751 751 sp->srings = sr; 752 752 sp->rx_desc = sp->srings->rxvector; 753 753 sp->tx_desc = sp->srings->txvector; 754 + spin_lock_init(&sp->tx_lock); 754 755 755 756 /* A couple calculations now, saves many cycles later. */ 756 757 setup_rx_ring(dev, sp->rx_desc, SEEQ_RX_BUFFERS);
+5 -4
drivers/net/usb/qmi_wwan.c
··· 297 297 if (ret < 0) 298 298 goto err; 299 299 300 - if (info->subdriver && info->subdriver->suspend) 300 + if (intf == info->control && info->subdriver && info->subdriver->suspend) 301 301 ret = info->subdriver->suspend(intf, message); 302 302 if (ret < 0) 303 303 usbnet_resume(intf); ··· 310 310 struct usbnet *dev = usb_get_intfdata(intf); 311 311 struct qmi_wwan_state *info = (void *)&dev->data; 312 312 int ret = 0; 313 + bool callsub = (intf == info->control && info->subdriver && info->subdriver->resume); 313 314 314 - if (info->subdriver && info->subdriver->resume) 315 + if (callsub) 315 316 ret = info->subdriver->resume(intf); 316 317 if (ret < 0) 317 318 goto err; 318 319 ret = usbnet_resume(intf); 319 - if (ret < 0 && info->subdriver && info->subdriver->resume && info->subdriver->suspend) 320 + if (ret < 0 && callsub && info->subdriver->suspend) 320 321 info->subdriver->suspend(intf, PMSG_SUSPEND); 321 322 err: 322 323 return ret; ··· 399 398 /* 4. Gobi 1000 devices */ 400 399 {QMI_GOBI1K_DEVICE(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */ 401 400 {QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)}, /* HP un2400 Gobi Modem Device */ 402 - {QMI_GOBI1K_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Mobile Broadband Module */ 403 401 {QMI_GOBI1K_DEVICE(0x04da, 0x250d)}, /* Panasonic Gobi Modem device */ 404 402 {QMI_GOBI1K_DEVICE(0x413c, 0x8172)}, /* Dell Gobi Modem device */ 405 403 {QMI_GOBI1K_DEVICE(0x1410, 0xa001)}, /* Novatel Gobi Modem device */ ··· 440 440 {QMI_GOBI_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */ 441 441 {QMI_GOBI_DEVICE(0x05c6, 0x9205)}, /* Gobi 2000 Modem device */ 442 442 {QMI_GOBI_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */ 443 + {QMI_GOBI_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Mobile Broadband Module */ 443 444 {QMI_GOBI_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */ 444 445 {QMI_GOBI_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */ 445 446 {QMI_GOBI_DEVICE(0x1199, 0x901b)}, /* Sierra Wireless MC7770 */
+1 -1
drivers/net/usb/sierra_net.c
··· 656 656 return -EIO; 657 657 } 658 658 659 - *datap = *attrdata; 659 + *datap = le16_to_cpu(*attrdata); 660 660 661 661 kfree(attrdata); 662 662 return result;
+12 -4
drivers/net/usb/usbnet.c
··· 1201 1201 } 1202 1202 EXPORT_SYMBOL_GPL(usbnet_start_xmit); 1203 1203 1204 - static void rx_alloc_submit(struct usbnet *dev, gfp_t flags) 1204 + static int rx_alloc_submit(struct usbnet *dev, gfp_t flags) 1205 1205 { 1206 1206 struct urb *urb; 1207 1207 int i; 1208 + int ret = 0; 1208 1209 1209 1210 /* don't refill the queue all at once */ 1210 1211 for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) { 1211 1212 urb = usb_alloc_urb(0, flags); 1212 1213 if (urb != NULL) { 1213 - if (rx_submit(dev, urb, flags) == -ENOLINK) 1214 - return; 1214 + ret = rx_submit(dev, urb, flags); 1215 + if (ret) 1216 + goto err; 1217 + } else { 1218 + ret = -ENOMEM; 1219 + goto err; 1215 1220 } 1216 1221 } 1222 + err: 1223 + return ret; 1217 1224 } 1218 1225 1219 1226 /*-------------------------------------------------------------------------*/ ··· 1264 1257 int temp = dev->rxq.qlen; 1265 1258 1266 1259 if (temp < RX_QLEN(dev)) { 1267 - rx_alloc_submit(dev, GFP_ATOMIC); 1260 + if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK) 1261 + return; 1268 1262 if (temp != dev->rxq.qlen) 1269 1263 netif_dbg(dev, link, dev->net, 1270 1264 "rxqlen %d --> %d\n",
+1
drivers/net/wan/ixp4xx_hss.c
··· 10 10 11 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 12 13 + #include <linux/module.h> 13 14 #include <linux/bitops.h> 14 15 #include <linux/cdev.h> 15 16 #include <linux/dma-mapping.h>
+104 -1
drivers/net/wireless/ath/ath9k/ar9003_paprd.c
··· 142 142 }; 143 143 int training_power; 144 144 int i, val; 145 + u32 am2pm_mask = ah->paprd_ratemask; 145 146 146 147 if (IS_CHAN_2GHZ(ah->curchan)) 147 148 training_power = ar9003_get_training_power_2g(ah); ··· 159 158 } 160 159 ah->paprd_training_power = training_power; 161 160 161 + if (AR_SREV_9330(ah)) 162 + am2pm_mask = 0; 163 + 162 164 REG_RMW_FIELD(ah, AR_PHY_PAPRD_AM2AM, AR_PHY_PAPRD_AM2AM_MASK, 163 165 ah->paprd_ratemask); 164 166 REG_RMW_FIELD(ah, AR_PHY_PAPRD_AM2PM, AR_PHY_PAPRD_AM2PM_MASK, 165 - ah->paprd_ratemask); 167 + am2pm_mask); 166 168 REG_RMW_FIELD(ah, AR_PHY_PAPRD_HT40, AR_PHY_PAPRD_HT40_MASK, 167 169 ah->paprd_ratemask_ht40); 168 170 ··· 786 782 } 787 783 EXPORT_SYMBOL(ar9003_paprd_setup_gain_table); 788 784 785 + static bool ar9003_paprd_retrain_pa_in(struct ath_hw *ah, 786 + struct ath9k_hw_cal_data *caldata, 787 + int chain) 788 + { 789 + u32 *pa_in = caldata->pa_table[chain]; 790 + int capdiv_offset, quick_drop_offset; 791 + int capdiv2g, quick_drop; 792 + int count = 0; 793 + int i; 794 + 795 + if (!AR_SREV_9485(ah) && !AR_SREV_9330(ah)) 796 + return false; 797 + 798 + capdiv2g = REG_READ_FIELD(ah, AR_PHY_65NM_CH0_TXRF3, 799 + AR_PHY_65NM_CH0_TXRF3_CAPDIV2G); 800 + 801 + quick_drop = REG_READ_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3, 802 + AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_QUICK_DROP); 803 + 804 + if (quick_drop) 805 + quick_drop -= 0x40; 806 + 807 + for (i = 0; i < NUM_BIN + 1; i++) { 808 + if (pa_in[i] == 1400) 809 + count++; 810 + } 811 + 812 + if (AR_SREV_9485(ah)) { 813 + if (pa_in[23] < 800) { 814 + capdiv_offset = (int)((1000 - pa_in[23] + 75) / 150); 815 + capdiv2g += capdiv_offset; 816 + if (capdiv2g > 7) { 817 + capdiv2g = 7; 818 + if (pa_in[23] < 600) { 819 + quick_drop++; 820 + if (quick_drop > 0) 821 + quick_drop = 0; 822 + } 823 + } 824 + } else if (pa_in[23] == 1400) { 825 + quick_drop_offset = min_t(int, count / 3, 2); 826 + quick_drop += quick_drop_offset; 827 + capdiv2g += quick_drop_offset / 2; 828 + 829 + if (capdiv2g > 7) 830 + capdiv2g = 7; 831 + 832 + if (quick_drop > 0) { 833 + quick_drop = 0; 834 + capdiv2g -= quick_drop_offset; 835 + if (capdiv2g < 0) 836 + capdiv2g = 0; 837 + } 838 + } else { 839 + return false; 840 + } 841 + } else if (AR_SREV_9330(ah)) { 842 + if (pa_in[23] < 1000) { 843 + capdiv_offset = (1000 - pa_in[23]) / 100; 844 + capdiv2g += capdiv_offset; 845 + if (capdiv_offset > 3) { 846 + capdiv_offset = 1; 847 + quick_drop--; 848 + } 849 + 850 + capdiv2g += capdiv_offset; 851 + if (capdiv2g > 6) 852 + capdiv2g = 6; 853 + if (quick_drop < -4) 854 + quick_drop = -4; 855 + } else if (pa_in[23] == 1400) { 856 + if (count > 3) { 857 + quick_drop++; 858 + capdiv2g -= count / 4; 859 + if (quick_drop > -2) 860 + quick_drop = -2; 861 + } else { 862 + capdiv2g--; 863 + } 864 + 865 + if (capdiv2g < 0) 866 + capdiv2g = 0; 867 + } else { 868 + return false; 869 + } 870 + } 871 + 872 + REG_RMW_FIELD(ah, AR_PHY_65NM_CH0_TXRF3, 873 + AR_PHY_65NM_CH0_TXRF3_CAPDIV2G, capdiv2g); 874 + REG_RMW_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3, 875 + AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_QUICK_DROP, 876 + quick_drop); 877 + 878 + return true; 879 + } 880 + 789 881 int ar9003_paprd_create_curve(struct ath_hw *ah, 790 882 struct ath9k_hw_cal_data *caldata, int chain) 791 883 { ··· 916 816 917 817 if (!create_pa_curve(data_L, data_U, pa_table, small_signal_gain)) 918 818 status = -2; 819 + 820 + if (ar9003_paprd_retrain_pa_in(ah, caldata, chain)) 821 + status = -EINPROGRESS; 919 822 920 823 REG_CLR_BIT(ah, AR_PHY_PAPRD_TRAINER_STAT1, 921 824 AR_PHY_PAPRD_TRAINER_STAT1_PAPRD_TRAIN_DONE);
+4
drivers/net/wireless/ath/ath9k/ar9003_phy.h
··· 625 625 #define AR_PHY_AIC_CTRL_4_B0 (AR_SM_BASE + 0x4c0) 626 626 #define AR_PHY_AIC_STAT_2_B0 (AR_SM_BASE + 0x4cc) 627 627 628 + #define AR_PHY_65NM_CH0_TXRF3 0x16048 629 + #define AR_PHY_65NM_CH0_TXRF3_CAPDIV2G 0x0000001e 630 + #define AR_PHY_65NM_CH0_TXRF3_CAPDIV2G_S 1 631 + 628 632 #define AR_PHY_65NM_CH0_SYNTH4 0x1608c 629 633 #define AR_PHY_SYNTH4_LONG_SHIFT_SELECT (AR_SREV_9462(ah) ? 0x00000001 : 0x00000002) 630 634 #define AR_PHY_SYNTH4_LONG_SHIFT_SELECT_S (AR_SREV_9462(ah) ? 0 : 1)
+2 -1
drivers/net/wireless/ath/ath9k/gpio.c
··· 341 341 { 342 342 struct ath_btcoex *btcoex = &sc->btcoex; 343 343 344 - ath9k_gen_timer_stop(sc->sc_ah, btcoex->no_stomp_timer); 344 + if (btcoex->hw_timer_enabled) 345 + ath9k_gen_timer_stop(sc->sc_ah, btcoex->no_stomp_timer); 345 346 } 346 347 347 348 u16 ath9k_btcoex_aggr_limit(struct ath_softc *sc, u32 max_4ms_framelen)
+4 -7
drivers/net/wireless/ath/ath9k/hw.c
··· 463 463 ah->config.spurchans[i][1] = AR_NO_SPUR; 464 464 } 465 465 466 - /* PAPRD needs some more work to be enabled */ 467 - ah->config.paprd_disable = 1; 468 - 469 466 ah->config.rx_intr_mitigation = true; 470 467 ah->config.pcieSerDesWrite = true; 471 468 ··· 974 977 imr_reg |= AR_IMR_TXINTM | AR_IMR_TXMINTR; 975 978 else 976 979 imr_reg |= AR_IMR_TXOK; 977 - 978 - if (opmode == NL80211_IFTYPE_AP) 979 - imr_reg |= AR_IMR_MIB; 980 980 981 981 ENABLE_REGWRITE_BUFFER(ah); 982 982 ··· 1772 1778 /* Operating channel changed, reset channel calibration data */ 1773 1779 memset(caldata, 0, sizeof(*caldata)); 1774 1780 ath9k_init_nfcal_hist_buffer(ah, chan); 1781 + } else if (caldata) { 1782 + caldata->paprd_packet_sent = false; 1775 1783 } 1776 1784 ah->noise = ath9k_hw_getchan_noise(ah, chan); 1777 1785 ··· 2498 2502 pCap->tx_desc_len = sizeof(struct ar9003_txc); 2499 2503 pCap->txs_len = sizeof(struct ar9003_txs); 2500 2504 if (!ah->config.paprd_disable && 2501 - ah->eep_ops->get_eeprom(ah, EEP_PAPRD)) 2505 + ah->eep_ops->get_eeprom(ah, EEP_PAPRD) && 2506 + !AR_SREV_9462(ah)) 2502 2507 pCap->hw_caps |= ATH9K_HW_CAP_PAPRD; 2503 2508 } else { 2504 2509 pCap->tx_desc_len = sizeof(struct ath_desc);
+1
drivers/net/wireless/ath/ath9k/hw.h
··· 405 405 int8_t iCoff; 406 406 int8_t qCoff; 407 407 bool rtt_done; 408 + bool paprd_packet_sent; 408 409 bool paprd_done; 409 410 bool nfcal_pending; 410 411 bool nfcal_interference;
+9 -9
drivers/net/wireless/ath/ath9k/link.c
··· 254 254 int chain_ok = 0; 255 255 int chain; 256 256 int len = 1800; 257 + int ret; 257 258 258 - if (!caldata) 259 + if (!caldata || !caldata->paprd_packet_sent || caldata->paprd_done) 259 260 return; 260 261 261 262 ath9k_ps_wakeup(sc); ··· 283 282 continue; 284 283 285 284 chain_ok = 0; 286 - 287 - ath_dbg(common, CALIBRATE, 288 - "Sending PAPRD frame for thermal measurement on chain %d\n", 289 - chain); 290 - if (!ath_paprd_send_frame(sc, skb, chain)) 291 - goto fail_paprd; 292 - 293 285 ar9003_paprd_setup_gain_table(ah, chain); 294 286 295 287 ath_dbg(common, CALIBRATE, ··· 296 302 break; 297 303 } 298 304 299 - if (ar9003_paprd_create_curve(ah, caldata, chain)) { 305 + ret = ar9003_paprd_create_curve(ah, caldata, chain); 306 + if (ret == -EINPROGRESS) { 307 + ath_dbg(common, CALIBRATE, 308 + "PAPRD curve on chain %d needs to be re-trained\n", 309 + chain); 310 + break; 311 + } else if (ret) { 300 312 ath_dbg(common, CALIBRATE, 301 313 "PAPRD create curve failed on chain %d\n", 302 314 chain);
+3
drivers/net/wireless/ath/ath9k/xmit.c
··· 2018 2018 2019 2019 ath_dbg(common, XMIT, "TX complete: skb: %p\n", skb); 2020 2020 2021 + if (sc->sc_ah->caldata) 2022 + sc->sc_ah->caldata->paprd_packet_sent = true; 2023 + 2021 2024 if (!(tx_flags & ATH_TX_ERROR)) 2022 2025 /* Frame was ACKed */ 2023 2026 tx_info->flags |= IEEE80211_TX_STAT_ACK;
+15 -15
drivers/net/wireless/brcm80211/brcmfmac/usb.c
··· 519 519 else 520 520 devinfo->bus_pub.bus->dstats.tx_errors++; 521 521 522 - dev_kfree_skb(req->skb); 522 + brcmu_pkt_buf_free_skb(req->skb); 523 523 req->skb = NULL; 524 524 brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req); 525 525 ··· 540 540 devinfo->bus_pub.bus->dstats.rx_packets++; 541 541 } else { 542 542 devinfo->bus_pub.bus->dstats.rx_errors++; 543 - dev_kfree_skb(skb); 543 + brcmu_pkt_buf_free_skb(skb); 544 544 brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req); 545 545 return; 546 546 } ··· 550 550 if (brcmf_proto_hdrpull(devinfo->dev, &ifidx, skb) != 0) { 551 551 brcmf_dbg(ERROR, "rx protocol error\n"); 552 552 brcmu_pkt_buf_free_skb(skb); 553 + brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req); 553 554 devinfo->bus_pub.bus->dstats.rx_errors++; 554 555 } else { 555 556 brcmf_rx_packet(devinfo->dev, ifidx, skb); 556 557 brcmf_usb_rx_refill(devinfo, req); 557 558 } 558 559 } else { 559 - dev_kfree_skb(skb); 560 + brcmu_pkt_buf_free_skb(skb); 561 + brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req); 560 562 } 561 563 return; 562 564 ··· 583 581 usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->rx_pipe, 584 582 skb->data, skb_tailroom(skb), brcmf_usb_rx_complete, 585 583 req); 586 - req->urb->transfer_flags |= URB_ZERO_PACKET; 587 584 req->devinfo = devinfo; 585 + brcmf_usb_enq(devinfo, &devinfo->rx_postq, req); 588 586 589 587 ret = usb_submit_urb(req->urb, GFP_ATOMIC); 590 - if (ret == 0) { 591 - brcmf_usb_enq(devinfo, &devinfo->rx_postq, req); 592 - } else { 593 - dev_kfree_skb(req->skb); 588 + if (ret) { 589 + brcmf_usb_del_fromq(devinfo, req); 590 + brcmu_pkt_buf_free_skb(req->skb); 594 591 req->skb = NULL; 595 592 brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req); 596 593 } ··· 684 683 685 684 req = brcmf_usb_deq(devinfo, &devinfo->tx_freeq); 686 685 if (!req) { 686 + brcmu_pkt_buf_free_skb(skb); 687 687 brcmf_dbg(ERROR, "no req to send\n"); 688 688 return -ENOMEM; 689 - } 690 - if (!req->urb) { 691 - brcmf_dbg(ERROR, "no urb for req %p\n", req); 692 - return -ENOBUFS; 693 689 } 694 690 695 691 req->skb = skb; ··· 694 696 usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->tx_pipe, 695 697 skb->data, skb->len, brcmf_usb_tx_complete, req); 696 698 req->urb->transfer_flags |= URB_ZERO_PACKET; 699 + brcmf_usb_enq(devinfo, &devinfo->tx_postq, req); 697 700 ret = usb_submit_urb(req->urb, GFP_ATOMIC); 698 - if (!ret) { 699 - brcmf_usb_enq(devinfo, &devinfo->tx_postq, req); 700 - } else { 701 + if (ret) { 702 + brcmf_dbg(ERROR, "brcmf_usb_tx usb_submit_urb FAILED\n"); 703 + brcmf_usb_del_fromq(devinfo, req); 704 + brcmu_pkt_buf_free_skb(req->skb); 701 705 req->skb = NULL; 702 706 brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req); 703 707 }
+8 -7
drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
··· 1876 1876 } 1877 1877 1878 1878 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status)) { 1879 - scb_val.val = cpu_to_le32(0); 1879 + memset(&scb_val, 0, sizeof(scb_val)); 1880 1880 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_RSSI, &scb_val, 1881 1881 sizeof(struct brcmf_scb_val_le)); 1882 - if (err) 1882 + if (err) { 1883 1883 WL_ERR("Could not get rssi (%d)\n", err); 1884 - 1885 - rssi = le32_to_cpu(scb_val.val); 1886 - sinfo->filled |= STATION_INFO_SIGNAL; 1887 - sinfo->signal = rssi; 1888 - WL_CONN("RSSI %d dBm\n", rssi); 1884 + } else { 1885 + rssi = le32_to_cpu(scb_val.val); 1886 + sinfo->filled |= STATION_INFO_SIGNAL; 1887 + sinfo->signal = rssi; 1888 + WL_CONN("RSSI %d dBm\n", rssi); 1889 + } 1889 1890 } 1890 1891 1891 1892 done:
+5
drivers/net/wireless/libertas/if_sdio.c
··· 1326 1326 1327 1327 mmc_pm_flag_t flags = sdio_get_host_pm_caps(func); 1328 1328 1329 + /* If we're powered off anyway, just let the mmc layer remove the 1330 + * card. */ 1331 + if (!lbs_iface_active(card->priv)) 1332 + return -ENOSYS; 1333 + 1329 1334 dev_info(dev, "%s: suspend: PM flags = 0x%x\n", 1330 1335 sdio_func_id(func), flags); 1331 1336
+14 -1
drivers/net/wireless/mwifiex/cmdevt.c
··· 170 170 cmd_code = le16_to_cpu(host_cmd->command); 171 171 cmd_size = le16_to_cpu(host_cmd->size); 172 172 173 - skb_trim(cmd_node->cmd_skb, cmd_size); 173 + /* Adjust skb length */ 174 + if (cmd_node->cmd_skb->len > cmd_size) 175 + /* 176 + * cmd_size is less than sizeof(struct host_cmd_ds_command). 177 + * Trim off the unused portion. 178 + */ 179 + skb_trim(cmd_node->cmd_skb, cmd_size); 180 + else if (cmd_node->cmd_skb->len < cmd_size) 181 + /* 182 + * cmd_size is larger than sizeof(struct host_cmd_ds_command) 183 + * because we have appended custom IE TLV. Increase skb length 184 + * accordingly. 185 + */ 186 + skb_put(cmd_node->cmd_skb, cmd_size - cmd_node->cmd_skb->len); 174 187 175 188 do_gettimeofday(&tstamp); 176 189 dev_dbg(adapter->dev, "cmd: DNLD_CMD: (%lu.%lu): %#x, act %#x, len %d,"
+9
drivers/net/wireless/rt2x00/rt2400pci.c
··· 1611 1611 static int rt2400pci_probe_hw(struct rt2x00_dev *rt2x00dev) 1612 1612 { 1613 1613 int retval; 1614 + u32 reg; 1614 1615 1615 1616 /* 1616 1617 * Allocate eeprom data. ··· 1623 1622 retval = rt2400pci_init_eeprom(rt2x00dev); 1624 1623 if (retval) 1625 1624 return retval; 1625 + 1626 + /* 1627 + * Enable rfkill polling by setting GPIO direction of the 1628 + * rfkill switch GPIO pin correctly. 1629 + */ 1630 + rt2x00pci_register_read(rt2x00dev, GPIOCSR, &reg); 1631 + rt2x00_set_field32(&reg, GPIOCSR_BIT8, 1); 1632 + rt2x00pci_register_write(rt2x00dev, GPIOCSR, reg); 1626 1633 1627 1634 /* 1628 1635 * Initialize hw specifications.
+1
drivers/net/wireless/rt2x00/rt2400pci.h
··· 670 670 #define GPIOCSR_BIT5 FIELD32(0x00000020) 671 671 #define GPIOCSR_BIT6 FIELD32(0x00000040) 672 672 #define GPIOCSR_BIT7 FIELD32(0x00000080) 673 + #define GPIOCSR_BIT8 FIELD32(0x00000100) 673 674 674 675 /* 675 676 * BBPPCSR: BBP Pin control register.
+9
drivers/net/wireless/rt2x00/rt2500pci.c
··· 1929 1929 static int rt2500pci_probe_hw(struct rt2x00_dev *rt2x00dev) 1930 1930 { 1931 1931 int retval; 1932 + u32 reg; 1932 1933 1933 1934 /* 1934 1935 * Allocate eeprom data. ··· 1941 1940 retval = rt2500pci_init_eeprom(rt2x00dev); 1942 1941 if (retval) 1943 1942 return retval; 1943 + 1944 + /* 1945 + * Enable rfkill polling by setting GPIO direction of the 1946 + * rfkill switch GPIO pin correctly. 1947 + */ 1948 + rt2x00pci_register_read(rt2x00dev, GPIOCSR, &reg); 1949 + rt2x00_set_field32(&reg, GPIOCSR_DIR0, 1); 1950 + rt2x00pci_register_write(rt2x00dev, GPIOCSR, reg); 1944 1951 1945 1952 /* 1946 1953 * Initialize hw specifications.
+10 -1
drivers/net/wireless/rt2x00/rt2500usb.c
··· 283 283 u16 reg; 284 284 285 285 rt2500usb_register_read(rt2x00dev, MAC_CSR19, &reg); 286 - return rt2x00_get_field32(reg, MAC_CSR19_BIT7); 286 + return rt2x00_get_field16(reg, MAC_CSR19_BIT7); 287 287 } 288 288 289 289 #ifdef CONFIG_RT2X00_LIB_LEDS ··· 1768 1768 static int rt2500usb_probe_hw(struct rt2x00_dev *rt2x00dev) 1769 1769 { 1770 1770 int retval; 1771 + u16 reg; 1771 1772 1772 1773 /* 1773 1774 * Allocate eeprom data. ··· 1780 1779 retval = rt2500usb_init_eeprom(rt2x00dev); 1781 1780 if (retval) 1782 1781 return retval; 1782 + 1783 + /* 1784 + * Enable rfkill polling by setting GPIO direction of the 1785 + * rfkill switch GPIO pin correctly. 1786 + */ 1787 + rt2500usb_register_read(rt2x00dev, MAC_CSR19, &reg); 1788 + rt2x00_set_field16(&reg, MAC_CSR19_BIT8, 0); 1789 + rt2500usb_register_write(rt2x00dev, MAC_CSR19, reg); 1783 1790 1784 1791 /* 1785 1792 * Initialize hw specifications.
+9 -8
drivers/net/wireless/rt2x00/rt2500usb.h
··· 189 189 * MAC_CSR19: GPIO control register. 190 190 */ 191 191 #define MAC_CSR19 0x0426 192 - #define MAC_CSR19_BIT0 FIELD32(0x0001) 193 - #define MAC_CSR19_BIT1 FIELD32(0x0002) 194 - #define MAC_CSR19_BIT2 FIELD32(0x0004) 195 - #define MAC_CSR19_BIT3 FIELD32(0x0008) 196 - #define MAC_CSR19_BIT4 FIELD32(0x0010) 197 - #define MAC_CSR19_BIT5 FIELD32(0x0020) 198 - #define MAC_CSR19_BIT6 FIELD32(0x0040) 199 - #define MAC_CSR19_BIT7 FIELD32(0x0080) 192 + #define MAC_CSR19_BIT0 FIELD16(0x0001) 193 + #define MAC_CSR19_BIT1 FIELD16(0x0002) 194 + #define MAC_CSR19_BIT2 FIELD16(0x0004) 195 + #define MAC_CSR19_BIT3 FIELD16(0x0008) 196 + #define MAC_CSR19_BIT4 FIELD16(0x0010) 197 + #define MAC_CSR19_BIT5 FIELD16(0x0020) 198 + #define MAC_CSR19_BIT6 FIELD16(0x0040) 199 + #define MAC_CSR19_BIT7 FIELD16(0x0080) 200 + #define MAC_CSR19_BIT8 FIELD16(0x0100) 200 201 201 202 /* 202 203 * MAC_CSR20: LED control register.
+1
drivers/net/wireless/rt2x00/rt2800lib.c
··· 4089 4089 rt2800_register_write(rt2x00dev, LDO_CFG0, reg); 4090 4090 msleep(1); 4091 4091 rt2800_register_read(rt2x00dev, LDO_CFG0, &reg); 4092 + rt2x00_set_field32(&reg, LDO_CFG0_LDO_CORE_VLEVEL, 0); 4092 4093 rt2x00_set_field32(&reg, LDO_CFG0_BGSEL, 1); 4093 4094 rt2800_register_write(rt2x00dev, LDO_CFG0, reg); 4094 4095 }
+9
drivers/net/wireless/rt2x00/rt2800pci.c
··· 983 983 static int rt2800pci_probe_hw(struct rt2x00_dev *rt2x00dev) 984 984 { 985 985 int retval; 986 + u32 reg; 986 987 987 988 /* 988 989 * Allocate eeprom data. ··· 995 994 retval = rt2800_init_eeprom(rt2x00dev); 996 995 if (retval) 997 996 return retval; 997 + 998 + /* 999 + * Enable rfkill polling by setting GPIO direction of the 1000 + * rfkill switch GPIO pin correctly. 1001 + */ 1002 + rt2x00pci_register_read(rt2x00dev, GPIO_CTRL_CFG, &reg); 1003 + rt2x00_set_field32(&reg, GPIO_CTRL_CFG_GPIOD_BIT2, 1); 1004 + rt2x00pci_register_write(rt2x00dev, GPIO_CTRL_CFG, reg); 998 1005 999 1006 /* 1000 1007 * Initialize hw specifications.
+20 -2
drivers/net/wireless/rt2x00/rt2800usb.c
··· 667 667 skb_pull(entry->skb, RXINFO_DESC_SIZE); 668 668 669 669 /* 670 - * FIXME: we need to check for rx_pkt_len validity 670 + * Check for rx_pkt_len validity. Return if invalid, leaving 671 + * rxdesc->size zeroed out by the upper level. 671 672 */ 673 + if (unlikely(rx_pkt_len == 0 || 674 + rx_pkt_len > entry->queue->data_size)) { 675 + ERROR(entry->queue->rt2x00dev, 676 + "Bad frame size %d, forcing to 0\n", rx_pkt_len); 677 + return; 678 + } 679 + 672 680 rxd = (__le32 *)(entry->skb->data + rx_pkt_len); 673 681 674 682 /* ··· 744 736 static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev) 745 737 { 746 738 int retval; 739 + u32 reg; 747 740 748 741 /* 749 742 * Allocate eeprom data. ··· 756 747 retval = rt2800_init_eeprom(rt2x00dev); 757 748 if (retval) 758 749 return retval; 750 + 751 + /* 752 + * Enable rfkill polling by setting GPIO direction of the 753 + * rfkill switch GPIO pin correctly. 754 + */ 755 + rt2x00usb_register_read(rt2x00dev, GPIO_CTRL_CFG, &reg); 756 + rt2x00_set_field32(&reg, GPIO_CTRL_CFG_GPIOD_BIT2, 1); 757 + rt2x00usb_register_write(rt2x00dev, GPIO_CTRL_CFG, reg); 759 758 760 759 /* 761 760 * Initialize hw specifications. ··· 1174 1157 { USB_DEVICE(0x1690, 0x0744) }, 1175 1158 { USB_DEVICE(0x1690, 0x0761) }, 1176 1159 { USB_DEVICE(0x1690, 0x0764) }, 1160 + /* ASUS */ 1161 + { USB_DEVICE(0x0b05, 0x179d) }, 1177 1162 /* Cisco */ 1178 1163 { USB_DEVICE(0x167b, 0x4001) }, 1179 1164 /* EnGenius */ ··· 1241 1222 { USB_DEVICE(0x0b05, 0x1760) }, 1242 1223 { USB_DEVICE(0x0b05, 0x1761) }, 1243 1224 { USB_DEVICE(0x0b05, 0x1790) }, 1244 - { USB_DEVICE(0x0b05, 0x179d) }, 1245 1225 /* AzureWave */ 1246 1226 { USB_DEVICE(0x13d3, 0x3262) }, 1247 1227 { USB_DEVICE(0x13d3, 0x3284) },
+1 -1
drivers/net/wireless/rt2x00/rt2x00dev.c
··· 629 629 */ 630 630 if (unlikely(rxdesc.size == 0 || 631 631 rxdesc.size > entry->queue->data_size)) { 632 - WARNING(rt2x00dev, "Wrong frame size %d max %d.\n", 632 + ERROR(rt2x00dev, "Wrong frame size %d max %d.\n", 633 633 rxdesc.size, entry->queue->data_size); 634 634 dev_kfree_skb(entry->skb); 635 635 goto renew_skb;
+9
drivers/net/wireless/rt2x00/rt61pci.c
··· 2832 2832 static int rt61pci_probe_hw(struct rt2x00_dev *rt2x00dev) 2833 2833 { 2834 2834 int retval; 2835 + u32 reg; 2835 2836 2836 2837 /* 2837 2838 * Disable power saving. ··· 2849 2848 retval = rt61pci_init_eeprom(rt2x00dev); 2850 2849 if (retval) 2851 2850 return retval; 2851 + 2852 + /* 2853 + * Enable rfkill polling by setting GPIO direction of the 2854 + * rfkill switch GPIO pin correctly. 2855 + */ 2856 + rt2x00pci_register_read(rt2x00dev, MAC_CSR13, &reg); 2857 + rt2x00_set_field32(&reg, MAC_CSR13_BIT13, 1); 2858 + rt2x00pci_register_write(rt2x00dev, MAC_CSR13, reg); 2852 2859 2853 2860 /* 2854 2861 * Initialize hw specifications.
+1
drivers/net/wireless/rt2x00/rt61pci.h
··· 372 372 #define MAC_CSR13_BIT10 FIELD32(0x00000400) 373 373 #define MAC_CSR13_BIT11 FIELD32(0x00000800) 374 374 #define MAC_CSR13_BIT12 FIELD32(0x00001000) 375 + #define MAC_CSR13_BIT13 FIELD32(0x00002000) 375 376 376 377 /* 377 378 * MAC_CSR14: LED control register.
+9
drivers/net/wireless/rt2x00/rt73usb.c
··· 2177 2177 static int rt73usb_probe_hw(struct rt2x00_dev *rt2x00dev) 2178 2178 { 2179 2179 int retval; 2180 + u32 reg; 2180 2181 2181 2182 /* 2182 2183 * Allocate eeprom data. ··· 2189 2188 retval = rt73usb_init_eeprom(rt2x00dev); 2190 2189 if (retval) 2191 2190 return retval; 2191 + 2192 + /* 2193 + * Enable rfkill polling by setting GPIO direction of the 2194 + * rfkill switch GPIO pin correctly. 2195 + */ 2196 + rt2x00usb_register_read(rt2x00dev, MAC_CSR13, &reg); 2197 + rt2x00_set_field32(&reg, MAC_CSR13_BIT15, 0); 2198 + rt2x00usb_register_write(rt2x00dev, MAC_CSR13, reg); 2192 2199 2193 2200 /* 2194 2201 * Initialize hw specifications.
+3
drivers/net/wireless/rt2x00/rt73usb.h
··· 282 282 #define MAC_CSR13_BIT10 FIELD32(0x00000400) 283 283 #define MAC_CSR13_BIT11 FIELD32(0x00000800) 284 284 #define MAC_CSR13_BIT12 FIELD32(0x00001000) 285 + #define MAC_CSR13_BIT13 FIELD32(0x00002000) 286 + #define MAC_CSR13_BIT14 FIELD32(0x00004000) 287 + #define MAC_CSR13_BIT15 FIELD32(0x00008000) 285 288 286 289 /* 287 290 * MAC_CSR14: LED control register.
+1 -1
include/linux/mISDNhw.h
··· 183 183 unsigned short); 184 184 extern int mISDN_freedchannel(struct dchannel *); 185 185 extern void mISDN_clear_bchannel(struct bchannel *); 186 - extern int mISDN_freebchannel(struct bchannel *); 186 + extern void mISDN_freebchannel(struct bchannel *); 187 187 extern int mISDN_ctrl_bchannel(struct bchannel *, struct mISDN_ctrl_req *); 188 188 extern void queue_ch_frame(struct mISDNchannel *, u_int, 189 189 int, struct sk_buff *);
+13
include/linux/mlx4/device.h
··· 796 796 MLX4_NET_TRANS_RULE_NUM, /* should be last */ 797 797 }; 798 798 799 + extern const u16 __sw_id_hw[]; 800 + 801 + static inline int map_hw_to_sw_id(u16 header_id) 802 + { 803 + 804 + int i; 805 + for (i = 0; i < MLX4_NET_TRANS_RULE_NUM; i++) { 806 + if (header_id == __sw_id_hw[i]) 807 + return i; 808 + } 809 + return -EINVAL; 810 + } 811 + 799 812 enum mlx4_net_trans_promisc_mode { 800 813 MLX4_FS_PROMISC_NONE = 0, 801 814 MLX4_FS_PROMISC_UPLINK,
+1 -1
include/net/bluetooth/smp.h
··· 136 136 }; 137 137 138 138 /* SMP Commands */ 139 - int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level); 139 + int smp_conn_security(struct hci_conn *hcon, __u8 sec_level); 140 140 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb); 141 141 int smp_distribute_keys(struct l2cap_conn *conn, __u8 force); 142 142 int smp_user_confirm_reply(struct hci_conn *conn, u16 mgmt_op, __le32 passkey);
+3
include/net/xfrm.h
··· 273 273 int (*check)(struct xfrm_state *x, 274 274 struct sk_buff *skb, 275 275 __be32 net_seq); 276 + int (*recheck)(struct xfrm_state *x, 277 + struct sk_buff *skb, 278 + __be32 net_seq); 276 279 void (*notify)(struct xfrm_state *x, int event); 277 280 int (*overflow)(struct xfrm_state *x, struct sk_buff *skb); 278 281 };
+4
net/bluetooth/hci_conn.c
··· 29 29 #include <net/bluetooth/bluetooth.h> 30 30 #include <net/bluetooth/hci_core.h> 31 31 #include <net/bluetooth/a2mp.h> 32 + #include <net/bluetooth/smp.h> 32 33 33 34 static void hci_le_connect(struct hci_conn *conn) 34 35 { ··· 619 618 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type) 620 619 { 621 620 BT_DBG("hcon %p", conn); 621 + 622 + if (conn->type == LE_LINK) 623 + return smp_conn_security(conn, sec_level); 622 624 623 625 /* For sdp we don't need the link key. */ 624 626 if (sec_level == BT_SECURITY_SDP)
+6 -5
net/bluetooth/l2cap_core.c
··· 1199 1199 static void l2cap_conn_ready(struct l2cap_conn *conn) 1200 1200 { 1201 1201 struct l2cap_chan *chan; 1202 + struct hci_conn *hcon = conn->hcon; 1202 1203 1203 1204 BT_DBG("conn %p", conn); 1204 1205 1205 - if (!conn->hcon->out && conn->hcon->type == LE_LINK) 1206 + if (!hcon->out && hcon->type == LE_LINK) 1206 1207 l2cap_le_conn_ready(conn); 1207 1208 1208 - if (conn->hcon->out && conn->hcon->type == LE_LINK) 1209 - smp_conn_security(conn, conn->hcon->pending_sec_level); 1209 + if (hcon->out && hcon->type == LE_LINK) 1210 + smp_conn_security(hcon, hcon->pending_sec_level); 1210 1211 1211 1212 mutex_lock(&conn->chan_lock); 1212 1213 ··· 1220 1219 continue; 1221 1220 } 1222 1221 1223 - if (conn->hcon->type == LE_LINK) { 1224 - if (smp_conn_security(conn, chan->sec_level)) 1222 + if (hcon->type == LE_LINK) { 1223 + if (smp_conn_security(hcon, chan->sec_level)) 1225 1224 l2cap_chan_ready(chan); 1226 1225 1227 1226 } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
+1 -1
net/bluetooth/l2cap_sock.c
··· 616 616 break; 617 617 } 618 618 619 - if (smp_conn_security(conn, sec.level)) 619 + if (smp_conn_security(conn->hcon, sec.level)) 620 620 break; 621 621 sk->sk_state = BT_CONFIG; 622 622 chan->state = BT_CONFIG;
+5 -5
net/bluetooth/smp.c
··· 267 267 mgmt_auth_failed(conn->hcon->hdev, conn->dst, hcon->type, 268 268 hcon->dst_type, reason); 269 269 270 - if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 271 - cancel_delayed_work_sync(&conn->security_timer); 270 + cancel_delayed_work_sync(&conn->security_timer); 271 + 272 + if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) 272 273 smp_chan_destroy(conn); 273 - } 274 274 } 275 275 276 276 #define JUST_WORKS 0x00 ··· 760 760 return 0; 761 761 } 762 762 763 - int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level) 763 + int smp_conn_security(struct hci_conn *hcon, __u8 sec_level) 764 764 { 765 - struct hci_conn *hcon = conn->hcon; 765 + struct l2cap_conn *conn = hcon->l2cap_data; 766 766 struct smp_chan *smp = conn->smp_chan; 767 767 __u8 authreq; 768 768
+1 -1
net/bridge/netfilter/ebt_log.c
··· 80 80 unsigned int bitmask; 81 81 82 82 spin_lock_bh(&ebt_log_lock); 83 - printk("<%c>%s IN=%s OUT=%s MAC source = %pM MAC dest = %pM proto = 0x%04x", 83 + printk(KERN_SOH "%c%s IN=%s OUT=%s MAC source = %pM MAC dest = %pM proto = 0x%04x", 84 84 '0' + loginfo->u.log.level, prefix, 85 85 in ? in->name : "", out ? out->name : "", 86 86 eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,
+3 -2
net/caif/cfsrvl.c
··· 211 211 void (*put)(struct cflayer *lyr)) 212 212 { 213 213 struct cfsrvl *service; 214 - service = container_of(adapt_layer->dn, struct cfsrvl, layer); 215 214 216 - WARN_ON(adapt_layer == NULL || adapt_layer->dn == NULL); 215 + if (WARN_ON(adapt_layer == NULL || adapt_layer->dn == NULL)) 216 + return; 217 + service = container_of(adapt_layer->dn, struct cfsrvl, layer); 217 218 service->hold = hold; 218 219 service->put = put; 219 220 }
+6 -5
net/core/dev.c
··· 2647 2647 if (!skb_flow_dissect(skb, &keys)) 2648 2648 return; 2649 2649 2650 - if (keys.ports) { 2651 - if ((__force u16)keys.port16[1] < (__force u16)keys.port16[0]) 2652 - swap(keys.port16[0], keys.port16[1]); 2650 + if (keys.ports) 2653 2651 skb->l4_rxhash = 1; 2654 - } 2655 2652 2656 2653 /* get a consistent hash (same value on both flow directions) */ 2657 - if ((__force u32)keys.dst < (__force u32)keys.src) 2654 + if (((__force u32)keys.dst < (__force u32)keys.src) || 2655 + (((__force u32)keys.dst == (__force u32)keys.src) && 2656 + ((__force u16)keys.port16[1] < (__force u16)keys.port16[0]))) { 2658 2657 swap(keys.dst, keys.src); 2658 + swap(keys.port16[0], keys.port16[1]); 2659 + } 2659 2660 2660 2661 hash = jhash_3words((__force u32)keys.dst, 2661 2662 (__force u32)keys.src,
+1 -1
net/core/pktgen.c
··· 2721 2721 /* Eth + IPh + UDPh + mpls */ 2722 2722 datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 - 2723 2723 pkt_dev->pkt_overhead; 2724 - if (datalen < sizeof(struct pktgen_hdr)) 2724 + if (datalen < 0 || datalen < sizeof(struct pktgen_hdr)) 2725 2725 datalen = sizeof(struct pktgen_hdr); 2726 2726 2727 2727 udph->source = htons(pkt_dev->cur_udp_src);
+8 -1
net/core/sock.c
··· 1523 1523 1524 1524 void sock_edemux(struct sk_buff *skb) 1525 1525 { 1526 - sock_put(skb->sk); 1526 + struct sock *sk = skb->sk; 1527 + 1528 + #ifdef CONFIG_INET 1529 + if (sk->sk_state == TCP_TIME_WAIT) 1530 + inet_twsk_put(inet_twsk(sk)); 1531 + else 1532 + #endif 1533 + sock_put(sk); 1527 1534 } 1528 1535 EXPORT_SYMBOL(sock_edemux); 1529 1536
+5
net/ipv4/udp.c
··· 1226 1226 1227 1227 if (unlikely(err)) { 1228 1228 trace_kfree_skb(skb, udp_recvmsg); 1229 + if (!peeked) { 1230 + atomic_inc(&sk->sk_drops); 1231 + UDP_INC_STATS_USER(sock_net(sk), 1232 + UDP_MIB_INERRORS, is_udplite); 1233 + } 1229 1234 goto out_free; 1230 1235 } 1231 1236
+3 -2
net/ipv6/tcp_ipv6.c
··· 403 403 tp->mtu_info = ntohl(info); 404 404 if (!sock_owned_by_user(sk)) 405 405 tcp_v6_mtu_reduced(sk); 406 - else 407 - set_bit(TCP_MTU_REDUCED_DEFERRED, &tp->tsq_flags); 406 + else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, 407 + &tp->tsq_flags)) 408 + sock_hold(sk); 408 409 goto out; 409 410 } 410 411
+11
net/ipv6/udp.c
··· 394 394 } 395 395 if (unlikely(err)) { 396 396 trace_kfree_skb(skb, udpv6_recvmsg); 397 + if (!peeked) { 398 + atomic_inc(&sk->sk_drops); 399 + if (is_udp4) 400 + UDP_INC_STATS_USER(sock_net(sk), 401 + UDP_MIB_INERRORS, 402 + is_udplite); 403 + else 404 + UDP6_INC_STATS_USER(sock_net(sk), 405 + UDP_MIB_INERRORS, 406 + is_udplite); 407 + } 397 408 goto out_free; 398 409 } 399 410 if (!peeked) {
+4
net/l2tp/l2tp_core.c
··· 1501 1501 return err; 1502 1502 } 1503 1503 1504 + static struct lock_class_key l2tp_socket_class; 1505 + 1504 1506 int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32 peer_tunnel_id, struct l2tp_tunnel_cfg *cfg, struct l2tp_tunnel **tunnelp) 1505 1507 { 1506 1508 struct l2tp_tunnel *tunnel = NULL; ··· 1607 1605 tunnel->old_sk_destruct = sk->sk_destruct; 1608 1606 sk->sk_destruct = &l2tp_tunnel_destruct; 1609 1607 tunnel->sock = sk; 1608 + lockdep_set_class_and_name(&sk->sk_lock.slock, &l2tp_socket_class, "l2tp_sock"); 1609 + 1610 1610 sk->sk_allocation = GFP_ATOMIC; 1611 1611 1612 1612 /* Add tunnel to our list */
+1 -1
net/l2tp/l2tp_eth.c
··· 153 153 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, skb->data, length); 154 154 } 155 155 156 - if (!pskb_may_pull(skb, sizeof(ETH_HLEN))) 156 + if (!pskb_may_pull(skb, ETH_HLEN)) 157 157 goto error; 158 158 159 159 secpath_reset(skb);
+4 -5
net/mac80211/cfg.c
··· 1378 1378 else 1379 1379 memset(next_hop, 0, ETH_ALEN); 1380 1380 1381 + memset(pinfo, 0, sizeof(*pinfo)); 1382 + 1381 1383 pinfo->generation = mesh_paths_generation; 1382 1384 1383 1385 pinfo->filled = MPATH_INFO_FRAME_QLEN | ··· 1398 1396 pinfo->discovery_timeout = 1399 1397 jiffies_to_msecs(mpath->discovery_timeout); 1400 1398 pinfo->discovery_retries = mpath->discovery_retries; 1401 - pinfo->flags = 0; 1402 1399 if (mpath->flags & MESH_PATH_ACTIVE) 1403 1400 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE; 1404 1401 if (mpath->flags & MESH_PATH_RESOLVING) ··· 1406 1405 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID; 1407 1406 if (mpath->flags & MESH_PATH_FIXED) 1408 1407 pinfo->flags |= NL80211_MPATH_FLAG_FIXED; 1409 - if (mpath->flags & MESH_PATH_RESOLVING) 1410 - pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 1411 - 1412 - pinfo->flags = mpath->flags; 1408 + if (mpath->flags & MESH_PATH_RESOLVED) 1409 + pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED; 1413 1410 } 1414 1411 1415 1412 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
+4
net/mac80211/mlme.c
··· 3248 3248 goto out_unlock; 3249 3249 3250 3250 err_clear: 3251 + memset(ifmgd->bssid, 0, ETH_ALEN); 3252 + ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID); 3251 3253 ifmgd->auth_data = NULL; 3252 3254 err_free: 3253 3255 kfree(auth_data); ··· 3441 3439 err = 0; 3442 3440 goto out; 3443 3441 err_clear: 3442 + memset(ifmgd->bssid, 0, ETH_ALEN); 3443 + ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID); 3444 3444 ifmgd->assoc_data = NULL; 3445 3445 err_free: 3446 3446 kfree(assoc_data);
+10 -19
net/netfilter/nf_conntrack_proto_tcp.c
··· 158 158 * sCL -> sSS 159 159 */ 160 160 /* sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2 */ 161 - /*synack*/ { sIV, sIV, sIG, sIG, sIG, sIG, sIG, sIG, sIG, sSR }, 161 + /*synack*/ { sIV, sIV, sSR, sIV, sIV, sIV, sIV, sIV, sIV, sSR }, 162 162 /* 163 163 * sNO -> sIV Too late and no reason to do anything 164 164 * sSS -> sIV Client can't send SYN and then SYN/ACK 165 165 * sS2 -> sSR SYN/ACK sent to SYN2 in simultaneous open 166 - * sSR -> sIG 167 - * sES -> sIG Error: SYNs in window outside the SYN_SENT state 168 - * are errors. Receiver will reply with RST 169 - * and close the connection. 170 - * Or we are not in sync and hold a dead connection. 171 - * sFW -> sIG 172 - * sCW -> sIG 173 - * sLA -> sIG 174 - * sTW -> sIG 175 - * sCL -> sIG 166 + * sSR -> sSR Late retransmitted SYN/ACK in simultaneous open 167 + * sES -> sIV Invalid SYN/ACK packets sent by the client 168 + * sFW -> sIV 169 + * sCW -> sIV 170 + * sLA -> sIV 171 + * sTW -> sIV 172 + * sCL -> sIV 176 173 */ 177 174 /* sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2 */ 178 175 /*fin*/ { sIV, sIV, sFW, sFW, sLA, sLA, sLA, sTW, sCL, sIV }, ··· 630 633 ack = sack = receiver->td_end; 631 634 } 632 635 633 - if (seq == end 634 - && (!tcph->rst 635 - || (seq == 0 && state->state == TCP_CONNTRACK_SYN_SENT))) 636 + if (tcph->rst && seq == 0 && state->state == TCP_CONNTRACK_SYN_SENT) 636 637 /* 637 - * Packets contains no data: we assume it is valid 638 - * and check the ack value only. 639 - * However RST segments are always validated by their 640 - * SEQ number, except when seq == 0 (reset sent answering 641 - * SYN. 638 + * RST sent answering SYN. 642 639 */ 643 640 seq = end = sender->td_end; 644 641
+19 -18
net/netfilter/xt_LOG.c
··· 145 145 return 0; 146 146 } 147 147 148 + static void dump_sk_uid_gid(struct sbuff *m, struct sock *sk) 149 + { 150 + if (!sk || sk->sk_state == TCP_TIME_WAIT) 151 + return; 152 + 153 + read_lock_bh(&sk->sk_callback_lock); 154 + if (sk->sk_socket && sk->sk_socket->file) 155 + sb_add(m, "UID=%u GID=%u ", 156 + sk->sk_socket->file->f_cred->fsuid, 157 + sk->sk_socket->file->f_cred->fsgid); 158 + read_unlock_bh(&sk->sk_callback_lock); 159 + } 160 + 148 161 /* One level of recursion won't kill us */ 149 162 static void dump_ipv4_packet(struct sbuff *m, 150 163 const struct nf_loginfo *info, ··· 374 361 } 375 362 376 363 /* Max length: 15 "UID=4294967295 " */ 377 - if ((logflags & XT_LOG_UID) && !iphoff && skb->sk) { 378 - read_lock_bh(&skb->sk->sk_callback_lock); 379 - if (skb->sk->sk_socket && skb->sk->sk_socket->file) 380 - sb_add(m, "UID=%u GID=%u ", 381 - skb->sk->sk_socket->file->f_cred->fsuid, 382 - skb->sk->sk_socket->file->f_cred->fsgid); 383 - read_unlock_bh(&skb->sk->sk_callback_lock); 384 - } 364 + if ((logflags & XT_LOG_UID) && !iphoff) 365 + dump_sk_uid_gid(m, skb->sk); 385 366 386 367 /* Max length: 16 "MARK=0xFFFFFFFF " */ 387 368 if (!iphoff && skb->mark) ··· 443 436 const struct nf_loginfo *loginfo, 444 437 const char *prefix) 445 438 { 446 - sb_add(m, "<%d>%sIN=%s OUT=%s ", loginfo->u.log.level, 447 - prefix, 439 + sb_add(m, KERN_SOH "%c%sIN=%s OUT=%s ", 440 + '0' + loginfo->u.log.level, prefix, 448 441 in ? in->name : "", 449 442 out ? out->name : ""); 450 443 #ifdef CONFIG_BRIDGE_NETFILTER ··· 724 717 } 725 718 726 719 /* Max length: 15 "UID=4294967295 " */ 727 - if ((logflags & XT_LOG_UID) && recurse && skb->sk) { 728 - read_lock_bh(&skb->sk->sk_callback_lock); 729 - if (skb->sk->sk_socket && skb->sk->sk_socket->file) 730 - sb_add(m, "UID=%u GID=%u ", 731 - skb->sk->sk_socket->file->f_cred->fsuid, 732 - skb->sk->sk_socket->file->f_cred->fsgid); 733 - read_unlock_bh(&skb->sk->sk_callback_lock); 734 - } 720 + if ((logflags & XT_LOG_UID) && recurse) 721 + dump_sk_uid_gid(m, skb->sk); 735 722 736 723 /* Max length: 16 "MARK=0xFFFFFFFF " */ 737 724 if (!recurse && skb->mark)
+6 -1
net/netrom/af_netrom.c
··· 1169 1169 msg->msg_flags |= MSG_TRUNC; 1170 1170 } 1171 1171 1172 - skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1172 + er = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1173 + if (er < 0) { 1174 + skb_free_datagram(sk, skb); 1175 + release_sock(sk); 1176 + return er; 1177 + } 1173 1178 1174 1179 if (sax != NULL) { 1175 1180 sax->sax25_family = AF_NETROM;
+1 -1
net/openvswitch/actions.c
··· 45 45 return pskb_expand_head(skb, 0, 0, GFP_ATOMIC); 46 46 } 47 47 48 - /* remove VLAN header from packet and update csum accrodingly. */ 48 + /* remove VLAN header from packet and update csum accordingly. */ 49 49 static int __pop_vlan_tci(struct sk_buff *skb, __be16 *current_tci) 50 50 { 51 51 struct vlan_hdr *vhdr;
+3 -3
net/openvswitch/datapath.c
··· 425 425 static int validate_tp_port(const struct sw_flow_key *flow_key) 426 426 { 427 427 if (flow_key->eth.type == htons(ETH_P_IP)) { 428 - if (flow_key->ipv4.tp.src && flow_key->ipv4.tp.dst) 428 + if (flow_key->ipv4.tp.src || flow_key->ipv4.tp.dst) 429 429 return 0; 430 430 } else if (flow_key->eth.type == htons(ETH_P_IPV6)) { 431 - if (flow_key->ipv6.tp.src && flow_key->ipv6.tp.dst) 431 + if (flow_key->ipv6.tp.src || flow_key->ipv6.tp.dst) 432 432 return 0; 433 433 } 434 434 ··· 460 460 if (flow_key->eth.type != htons(ETH_P_IP)) 461 461 return -EINVAL; 462 462 463 - if (!flow_key->ipv4.addr.src || !flow_key->ipv4.addr.dst) 463 + if (!flow_key->ip.proto) 464 464 return -EINVAL; 465 465 466 466 ipv4_key = nla_data(ovs_key);
+5 -3
net/openvswitch/flow.h
··· 145 145 * OVS_KEY_ATTR_PRIORITY 4 -- 4 8 146 146 * OVS_KEY_ATTR_IN_PORT 4 -- 4 8 147 147 * OVS_KEY_ATTR_ETHERNET 12 -- 4 16 148 + * OVS_KEY_ATTR_ETHERTYPE 2 2 4 8 (outer VLAN ethertype) 148 149 * OVS_KEY_ATTR_8021Q 4 -- 4 8 149 - * OVS_KEY_ATTR_ETHERTYPE 2 2 4 8 150 + * OVS_KEY_ATTR_ENCAP 0 -- 4 4 (VLAN encapsulation) 151 + * OVS_KEY_ATTR_ETHERTYPE 2 2 4 8 (inner VLAN ethertype) 150 152 * OVS_KEY_ATTR_IPV6 40 -- 4 44 151 153 * OVS_KEY_ATTR_ICMPV6 2 2 4 8 152 154 * OVS_KEY_ATTR_ND 28 -- 4 32 153 155 * ------------------------------------------------- 154 - * total 132 156 + * total 144 155 157 */ 156 - #define FLOW_BUFSIZE 132 158 + #define FLOW_BUFSIZE 144 157 159 158 160 int ovs_flow_to_nlattrs(const struct sw_flow_key *, struct sk_buff *); 159 161 int ovs_flow_from_nlattrs(struct sw_flow_key *swkey, int *key_lenp,
+3 -2
net/sched/sch_cbq.c
··· 250 250 else if ((cl = defmap[res.classid & TC_PRIO_MAX]) == NULL) 251 251 cl = defmap[TC_PRIO_BESTEFFORT]; 252 252 253 - if (cl == NULL || cl->level >= head->level) 253 + if (cl == NULL) 254 254 goto fallback; 255 255 } 256 - 256 + if (cl->level >= head->level) 257 + goto fallback; 257 258 #ifdef CONFIG_NET_CLS_ACT 258 259 switch (result) { 259 260 case TC_ACT_QUEUED:
+1 -1
net/sched/sch_fq_codel.c
··· 191 191 192 192 if (list_empty(&flow->flowchain)) { 193 193 list_add_tail(&flow->flowchain, &q->new_flows); 194 - codel_vars_init(&flow->cvars); 195 194 q->new_flow_count++; 196 195 flow->deficit = q->quantum; 197 196 flow->dropped = 0; ··· 417 418 struct fq_codel_flow *flow = q->flows + i; 418 419 419 420 INIT_LIST_HEAD(&flow->flowchain); 421 + codel_vars_init(&flow->cvars); 420 422 } 421 423 } 422 424 if (sch->limit >= 1)
+22 -16
net/sched/sch_gred.c
··· 102 102 if (q == NULL) 103 103 continue; 104 104 105 - for (n = 0; n < table->DPs; n++) 106 - if (table->tab[n] && table->tab[n] != q && 107 - table->tab[n]->prio == q->prio) 105 + for (n = i + 1; n < table->DPs; n++) 106 + if (table->tab[n] && table->tab[n]->prio == q->prio) 108 107 return 1; 109 108 } 110 109 ··· 136 137 struct gred_sched_data *q) 137 138 { 138 139 table->wred_set.qavg = q->vars.qavg; 140 + table->wred_set.qidlestart = q->vars.qidlestart; 139 141 } 140 142 141 143 static inline int gred_use_ecn(struct gred_sched *t) ··· 176 176 skb->tc_index = (skb->tc_index & ~GRED_VQ_MASK) | dp; 177 177 } 178 178 179 - /* sum up all the qaves of prios <= to ours to get the new qave */ 179 + /* sum up all the qaves of prios < ours to get the new qave */ 180 180 if (!gred_wred_mode(t) && gred_rio_mode(t)) { 181 181 int i; 182 182 ··· 260 260 } else { 261 261 q->backlog -= qdisc_pkt_len(skb); 262 262 263 - if (!q->backlog && !gred_wred_mode(t)) 264 - red_start_of_idle_period(&q->vars); 263 + if (gred_wred_mode(t)) { 264 + if (!sch->qstats.backlog) 265 + red_start_of_idle_period(&t->wred_set); 266 + } else { 267 + if (!q->backlog) 268 + red_start_of_idle_period(&q->vars); 269 + } 265 270 } 266 271 267 272 return skb; 268 273 } 269 - 270 - if (gred_wred_mode(t) && !red_is_idling(&t->wred_set)) 271 - red_start_of_idle_period(&t->wred_set); 272 274 273 275 return NULL; 274 276 } ··· 293 291 q->backlog -= len; 294 292 q->stats.other++; 295 293 296 - if (!q->backlog && !gred_wred_mode(t)) 297 - red_start_of_idle_period(&q->vars); 294 + if (gred_wred_mode(t)) { 295 + if (!sch->qstats.backlog) 296 + red_start_of_idle_period(&t->wred_set); 297 + } else { 298 + if (!q->backlog) 299 + red_start_of_idle_period(&q->vars); 300 + } 298 301 } 299 302 300 303 qdisc_drop(skb, sch); 301 304 return len; 302 305 } 303 306 304 - if (gred_wred_mode(t) && !red_is_idling(&t->wred_set)) 305 - red_start_of_idle_period(&t->wred_set); 306 - 307 307 return 0; 308 - 309 308 } 310 309 311 310 static void gred_reset(struct Qdisc *sch) ··· 538 535 for (i = 0; i < MAX_DPs; i++) { 539 536 struct gred_sched_data *q = table->tab[i]; 540 537 struct tc_gred_qopt opt; 538 + unsigned long qavg; 541 539 542 540 memset(&opt, 0, sizeof(opt)); 543 541 ··· 570 566 if (gred_wred_mode(table)) 571 567 gred_load_wred_set(table, q); 572 568 573 - opt.qave = red_calc_qavg(&q->parms, &q->vars, q->vars.qavg); 569 + qavg = red_calc_qavg(&q->parms, &q->vars, 570 + q->vars.qavg >> q->parms.Wlog); 571 + opt.qave = qavg >> q->parms.Wlog; 574 572 575 573 append_opt: 576 574 if (nla_append(skb, sizeof(opt), &opt) < 0)
+20 -1
net/sctp/output.c
··· 364 364 return retval; 365 365 } 366 366 367 + static void sctp_packet_release_owner(struct sk_buff *skb) 368 + { 369 + sk_free(skb->sk); 370 + } 371 + 372 + static void sctp_packet_set_owner_w(struct sk_buff *skb, struct sock *sk) 373 + { 374 + skb_orphan(skb); 375 + skb->sk = sk; 376 + skb->destructor = sctp_packet_release_owner; 377 + 378 + /* 379 + * The data chunks have already been accounted for in sctp_sendmsg(), 380 + * therefore only reserve a single byte to keep socket around until 381 + * the packet has been transmitted. 382 + */ 383 + atomic_inc(&sk->sk_wmem_alloc); 384 + } 385 + 367 386 /* All packets are sent to the network through this function from 368 387 * sctp_outq_tail(). 369 388 * ··· 424 405 /* Set the owning socket so that we know where to get the 425 406 * destination IP address. 426 407 */ 427 - skb_set_owner_w(nskb, sk); 408 + sctp_packet_set_owner_w(nskb, sk); 428 409 429 410 if (!sctp_transport_dst_check(tp)) { 430 411 sctp_transport_route(tp, NULL, sctp_sk(sk));
+3 -1
net/wireless/nl80211.c
··· 5633 5633 sizeof(connect.ht_capa_mask)); 5634 5634 5635 5635 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) { 5636 - if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) 5636 + if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) { 5637 + kfree(connkeys); 5637 5638 return -EINVAL; 5639 + } 5638 5640 memcpy(&connect.ht_capa, 5639 5641 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]), 5640 5642 sizeof(connect.ht_capa));
+1 -1
net/xfrm/xfrm_input.c
··· 212 212 /* only the first xfrm gets the encap type */ 213 213 encap_type = 0; 214 214 215 - if (async && x->repl->check(x, skb, seq)) { 215 + if (async && x->repl->recheck(x, skb, seq)) { 216 216 XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR); 217 217 goto drop_unlock; 218 218 }
+15
net/xfrm/xfrm_replay.c
··· 420 420 return -EINVAL; 421 421 } 422 422 423 + static int xfrm_replay_recheck_esn(struct xfrm_state *x, 424 + struct sk_buff *skb, __be32 net_seq) 425 + { 426 + if (unlikely(XFRM_SKB_CB(skb)->seq.input.hi != 427 + htonl(xfrm_replay_seqhi(x, net_seq)))) { 428 + x->stats.replay_window++; 429 + return -EINVAL; 430 + } 431 + 432 + return xfrm_replay_check_esn(x, skb, net_seq); 433 + } 434 + 423 435 static void xfrm_replay_advance_esn(struct xfrm_state *x, __be32 net_seq) 424 436 { 425 437 unsigned int bitnr, nr, i; ··· 491 479 static struct xfrm_replay xfrm_replay_legacy = { 492 480 .advance = xfrm_replay_advance, 493 481 .check = xfrm_replay_check, 482 + .recheck = xfrm_replay_check, 494 483 .notify = xfrm_replay_notify, 495 484 .overflow = xfrm_replay_overflow, 496 485 }; ··· 499 486 static struct xfrm_replay xfrm_replay_bmp = { 500 487 .advance = xfrm_replay_advance_bmp, 501 488 .check = xfrm_replay_check_bmp, 489 + .recheck = xfrm_replay_check_bmp, 502 490 .notify = xfrm_replay_notify_bmp, 503 491 .overflow = xfrm_replay_overflow_bmp, 504 492 }; ··· 507 493 static struct xfrm_replay xfrm_replay_esn = { 508 494 .advance = xfrm_replay_advance_esn, 509 495 .check = xfrm_replay_check_esn, 496 + .recheck = xfrm_replay_recheck_esn, 510 497 .notify = xfrm_replay_notify_bmp, 511 498 .overflow = xfrm_replay_overflow_esn, 512 499 };