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-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (68 commits)
net: can: janz-ican3: world-writable sysfs termination file
net: can: at91_can: world-writable sysfs files
MAINTAINERS: update email ids of the be2net driver maintainers.
bridge: Don't put partly initialized fdb into hash
r8169: prevent RxFIFO induced loops in the irq handler.
r8169: RxFIFO overflow oddities with 8168 chipsets.
r8169: use RxFIFO overflow workaround for 8168c chipset.
include/net/genetlink.h: Allow genlmsg_cancel to accept a NULL argument
net: Provide compat support for SIOCGETMIFCNT_IN6 and SIOCGETSGCNT_IN6.
net: Support compat SIOCGETVIFCNT ioctl in ipv4.
net: Fix bug in compat SIOCGETSGCNT handling.
niu: Fix races between up/down and get_stats.
tcp_ecn is an integer not a boolean
atl1c: Add missing PCI device ID
s390: Fix possibly wrong size in strncmp (smsgiucv)
s390: Fix wrong size in memcmp (netiucv)
qeth: allow OSA CHPARM change in suspend state
qeth: allow HiperSockets framesize change in suspend
qeth: add more strict MTU checking
qeth: show new mac-address if its setting fails
...

Linus Torvalds 44f2c5c8 78d29788

+637 -289
+1 -1
Documentation/networking/ip-sysctl.txt
··· 187 187 tcp_dsack - BOOLEAN 188 188 Allows TCP to send "duplicate" SACKs. 189 189 190 - tcp_ecn - BOOLEAN 190 + tcp_ecn - INTEGER 191 191 Enable Explicit Congestion Notification (ECN) in TCP. ECN is only 192 192 used when both ends of the TCP flow support it. It is useful to 193 193 avoid losses due to congestion (when the bottleneck router supports
+7 -8
MAINTAINERS
··· 5551 5551 F: drivers/scsi/be2iscsi/ 5552 5552 5553 5553 SERVER ENGINES 10Gbps NIC - BladeEngine 2 DRIVER 5554 - M: Sathya Perla <sathyap@serverengines.com> 5555 - M: Subbu Seetharaman <subbus@serverengines.com> 5556 - M: Sarveshwar Bandi <sarveshwarb@serverengines.com> 5557 - M: Ajit Khaparde <ajitk@serverengines.com> 5554 + M: Sathya Perla <sathya.perla@emulex.com> 5555 + M: Subbu Seetharaman <subbu.seetharaman@emulex.com> 5556 + M: Ajit Khaparde <ajit.khaparde@emulex.com> 5558 5557 L: netdev@vger.kernel.org 5559 - W: http://www.serverengines.com 5558 + W: http://www.emulex.com 5560 5559 S: Supported 5561 5560 F: drivers/net/benet/ 5562 5561 ··· 6786 6787 F: drivers/net/wireless/wl1251/* 6787 6788 6788 6789 WL1271 WIRELESS DRIVER 6789 - M: Luciano Coelho <luciano.coelho@nokia.com> 6790 + M: Luciano Coelho <coelho@ti.com> 6790 6791 L: linux-wireless@vger.kernel.org 6791 - W: http://wireless.kernel.org 6792 + W: http://wireless.kernel.org/en/users/Drivers/wl12xx 6792 6793 T: git git://git.kernel.org/pub/scm/linux/kernel/git/luca/wl12xx.git 6793 6794 S: Maintained 6794 - F: drivers/net/wireless/wl12xx/wl1271* 6795 + F: drivers/net/wireless/wl12xx/ 6795 6796 F: include/linux/wl12xx.h 6796 6797 6797 6798 WL3501 WIRELESS PCMCIA CARD DRIVER
+2 -1
drivers/isdn/icn/icn.c
··· 1627 1627 static int __init icn_init(void) 1628 1628 { 1629 1629 char *p; 1630 - char rev[20]; 1630 + char rev[21]; 1631 1631 1632 1632 memset(&dev, 0, sizeof(icn_dev)); 1633 1633 dev.memaddr = (membase & 0x0ffc000); ··· 1638 1638 1639 1639 if ((p = strchr(revision, ':'))) { 1640 1640 strncpy(rev, p + 1, 20); 1641 + rev[20] = '\0'; 1641 1642 p = strchr(rev, '$'); 1642 1643 if (p) 1643 1644 *p = 0;
+1
drivers/net/atl1c/atl1c_main.c
··· 48 48 {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATHEROS_L2C_B)}, 49 49 {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATHEROS_L2C_B2)}, 50 50 {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATHEROS_L1D)}, 51 + {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATHEROS_L1D_2_0)}, 51 52 /* required last entry */ 52 53 { 0 } 53 54 };
-4
drivers/net/benet/be_main.c
··· 312 312 if (adapter->link_up != link_up) { 313 313 adapter->link_speed = -1; 314 314 if (link_up) { 315 - netif_start_queue(netdev); 316 315 netif_carrier_on(netdev); 317 316 printk(KERN_INFO "%s: Link up\n", netdev->name); 318 317 } else { 319 - netif_stop_queue(netdev); 320 318 netif_carrier_off(netdev); 321 319 printk(KERN_INFO "%s: Link down\n", netdev->name); 322 320 } ··· 2626 2628 2627 2629 netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc, 2628 2630 BE_NAPI_WEIGHT); 2629 - 2630 - netif_stop_queue(netdev); 2631 2631 } 2632 2632 2633 2633 static void be_unmap_pci_bars(struct be_adapter *adapter)
+2 -2
drivers/net/bnx2x/bnx2x.h
··· 22 22 * (you will need to reboot afterwards) */ 23 23 /* #define BNX2X_STOP_ON_ERROR */ 24 24 25 - #define DRV_MODULE_VERSION "1.62.00-4" 26 - #define DRV_MODULE_RELDATE "2011/01/18" 25 + #define DRV_MODULE_VERSION "1.62.00-5" 26 + #define DRV_MODULE_RELDATE "2011/01/30" 27 27 #define BNX2X_BC_VER 0x040200 28 28 29 29 #define BNX2X_MULTI_QUEUE
+18 -47
drivers/net/bnx2x/bnx2x_link.c
··· 3948 3948 return rc; 3949 3949 } 3950 3950 3951 - static void bnx2x_8073_set_xaui_low_power_mode(struct bnx2x *bp, 3952 - struct bnx2x_phy *phy) 3953 - { 3954 - u16 val; 3955 - bnx2x_cl45_read(bp, phy, 3956 - MDIO_PMA_DEVAD, MDIO_PMA_REG_8073_CHIP_REV, &val); 3957 - 3958 - if (val == 0) { 3959 - /* Mustn't set low power mode in 8073 A0 */ 3960 - return; 3961 - } 3962 - 3963 - /* Disable PLL sequencer (use read-modify-write to clear bit 13) */ 3964 - bnx2x_cl45_read(bp, phy, 3965 - MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, &val); 3966 - val &= ~(1<<13); 3967 - bnx2x_cl45_write(bp, phy, 3968 - MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, val); 3969 - 3970 - /* PLL controls */ 3971 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x805E, 0x1077); 3972 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x805D, 0x0000); 3973 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x805C, 0x030B); 3974 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x805B, 0x1240); 3975 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x805A, 0x2490); 3976 - 3977 - /* Tx Controls */ 3978 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x80A7, 0x0C74); 3979 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x80A6, 0x9041); 3980 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x80A5, 0x4640); 3981 - 3982 - /* Rx Controls */ 3983 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x80FE, 0x01C4); 3984 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x80FD, 0x9249); 3985 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, 0x80FC, 0x2015); 3986 - 3987 - /* Enable PLL sequencer (use read-modify-write to set bit 13) */ 3988 - bnx2x_cl45_read(bp, phy, MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, &val); 3989 - val |= (1<<13); 3990 - bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, val); 3991 - } 3992 - 3993 3951 /******************************************************************/ 3994 3952 /* BCM8073 PHY SECTION */ 3995 3953 /******************************************************************/ ··· 4105 4147 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 0x0004); 4106 4148 4107 4149 bnx2x_8073_set_pause_cl37(params, phy, vars); 4108 - 4109 - bnx2x_8073_set_xaui_low_power_mode(bp, phy); 4110 4150 4111 4151 bnx2x_cl45_read(bp, phy, 4112 4152 MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &tmp1); ··· 6475 6519 MDIO_PMA_DEVAD, 6476 6520 MDIO_PMA_REG_8481_LED1_MASK, 6477 6521 0x80); 6522 + 6523 + /* Tell LED3 to blink on source */ 6524 + bnx2x_cl45_read(bp, phy, 6525 + MDIO_PMA_DEVAD, 6526 + MDIO_PMA_REG_8481_LINK_SIGNAL, 6527 + &val); 6528 + val &= ~(7<<6); 6529 + val |= (1<<6); /* A83B[8:6]= 1 */ 6530 + bnx2x_cl45_write(bp, phy, 6531 + MDIO_PMA_DEVAD, 6532 + MDIO_PMA_REG_8481_LINK_SIGNAL, 6533 + val); 6478 6534 } 6479 6535 break; 6480 6536 } ··· 7688 7720 struct bnx2x_phy phy[PORT_MAX]; 7689 7721 struct bnx2x_phy *phy_blk[PORT_MAX]; 7690 7722 u16 val; 7691 - s8 port; 7723 + s8 port = 0; 7692 7724 s8 port_of_path = 0; 7693 - 7694 - bnx2x_ext_phy_hw_reset(bp, 0); 7725 + u32 swap_val, swap_override; 7726 + swap_val = REG_RD(bp, NIG_REG_PORT_SWAP); 7727 + swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE); 7728 + port ^= (swap_val && swap_override); 7729 + bnx2x_ext_phy_hw_reset(bp, port); 7695 7730 /* PART1 - Reset both phys */ 7696 7731 for (port = PORT_MAX - 1; port >= PORT_0; port--) { 7697 7732 u32 shmem_base, shmem2_base;
+13 -14
drivers/net/bnx2x/bnx2x_main.c
··· 2301 2301 /* accept matched ucast */ 2302 2302 drop_all_ucast = 0; 2303 2303 } 2304 - if (filters & BNX2X_ACCEPT_MULTICAST) { 2304 + if (filters & BNX2X_ACCEPT_MULTICAST) 2305 2305 /* accept matched mcast */ 2306 2306 drop_all_mcast = 0; 2307 - if (IS_MF_SI(bp)) 2308 - /* since mcast addresses won't arrive with ovlan, 2309 - * fw needs to accept all of them in 2310 - * switch-independent mode */ 2311 - accp_all_mcast = 1; 2312 - } 2307 + 2313 2308 if (filters & BNX2X_ACCEPT_ALL_UNICAST) { 2314 2309 /* accept all mcast */ 2315 2310 drop_all_ucast = 0; ··· 5291 5296 } 5292 5297 } 5293 5298 5294 - bp->port.need_hw_lock = bnx2x_hw_lock_required(bp, 5295 - bp->common.shmem_base, 5296 - bp->common.shmem2_base); 5297 - 5298 5299 bnx2x_setup_fan_failure_detection(bp); 5299 5300 5300 5301 /* clear PXP2 attentions */ ··· 5494 5503 5495 5504 bnx2x_init_block(bp, MCP_BLOCK, init_stage); 5496 5505 bnx2x_init_block(bp, DMAE_BLOCK, init_stage); 5497 - bp->port.need_hw_lock = bnx2x_hw_lock_required(bp, 5498 - bp->common.shmem_base, 5499 - bp->common.shmem2_base); 5500 5506 if (bnx2x_fan_failure_det_req(bp, bp->common.shmem_base, 5501 5507 bp->common.shmem2_base, port)) { 5502 5508 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 : ··· 8367 8379 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN)) 8368 8380 bp->mdio.prtad = 8369 8381 XGXS_EXT_PHY_ADDR(ext_phy_config); 8382 + 8383 + /* 8384 + * Check if hw lock is required to access MDC/MDIO bus to the PHY(s) 8385 + * In MF mode, it is set to cover self test cases 8386 + */ 8387 + if (IS_MF(bp)) 8388 + bp->port.need_hw_lock = 1; 8389 + else 8390 + bp->port.need_hw_lock = bnx2x_hw_lock_required(bp, 8391 + bp->common.shmem_base, 8392 + bp->common.shmem2_base); 8370 8393 } 8371 8394 8372 8395 static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
+1 -1
drivers/net/can/Kconfig
··· 23 23 24 24 As only the sending and receiving of CAN frames is implemented, this 25 25 driver should work with the (serial/USB) CAN hardware from: 26 - www.canusb.com / www.can232.com / www.mictronic.com / www.canhack.de 26 + www.canusb.com / www.can232.com / www.mictronics.de / www.canhack.de 27 27 28 28 Userspace tools to attach the SLCAN line discipline (slcan_attach, 29 29 slcand) can be found in the can-utils at the SocketCAN SVN, see
+1 -1
drivers/net/can/at91_can.c
··· 1109 1109 return ret; 1110 1110 } 1111 1111 1112 - static DEVICE_ATTR(mb0_id, S_IWUGO | S_IRUGO, 1112 + static DEVICE_ATTR(mb0_id, S_IWUSR | S_IRUGO, 1113 1113 at91_sysfs_show_mb0_id, at91_sysfs_set_mb0_id); 1114 1114 1115 1115 static struct attribute *at91_sysfs_attrs[] = {
+1 -1
drivers/net/can/janz-ican3.c
··· 1618 1618 return count; 1619 1619 } 1620 1620 1621 - static DEVICE_ATTR(termination, S_IWUGO | S_IRUGO, ican3_sysfs_show_term, 1621 + static DEVICE_ATTR(termination, S_IWUSR | S_IRUGO, ican3_sysfs_show_term, 1622 1622 ican3_sysfs_set_term); 1623 1623 1624 1624 static struct attribute *ican3_sysfs_attrs[] = {
+1 -1
drivers/net/can/softing/Kconfig
··· 1 1 config CAN_SOFTING 2 2 tristate "Softing Gmbh CAN generic support" 3 - depends on CAN_DEV 3 + depends on CAN_DEV && HAS_IOMEM 4 4 ---help--- 5 5 Support for CAN cards from Softing Gmbh & some cards 6 6 from Vector Gmbh.
+3 -3
drivers/net/depca.c
··· 1094 1094 } 1095 1095 } 1096 1096 /* Change buffer ownership for this last frame, back to the adapter */ 1097 - for (; lp->rx_old != entry; lp->rx_old = (++lp->rx_old) & lp->rxRingMask) { 1097 + for (; lp->rx_old != entry; lp->rx_old = (lp->rx_old + 1) & lp->rxRingMask) { 1098 1098 writel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, &lp->rx_ring[lp->rx_old].base); 1099 1099 } 1100 1100 writel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base); ··· 1103 1103 /* 1104 1104 ** Update entry information 1105 1105 */ 1106 - lp->rx_new = (++lp->rx_new) & lp->rxRingMask; 1106 + lp->rx_new = (lp->rx_new + 1) & lp->rxRingMask; 1107 1107 } 1108 1108 1109 1109 return 0; ··· 1148 1148 } 1149 1149 1150 1150 /* Update all the pointers */ 1151 - lp->tx_old = (++lp->tx_old) & lp->txRingMask; 1151 + lp->tx_old = (lp->tx_old + 1) & lp->txRingMask; 1152 1152 } 1153 1153 1154 1154 return 0;
+2 -2
drivers/net/dl2k.c
··· 1753 1753 1754 1754 /* Free all the skbuffs in the queue. */ 1755 1755 for (i = 0; i < RX_RING_SIZE; i++) { 1756 - np->rx_ring[i].status = 0; 1757 - np->rx_ring[i].fraginfo = 0; 1758 1756 skb = np->rx_skbuff[i]; 1759 1757 if (skb) { 1760 1758 pci_unmap_single(np->pdev, ··· 1761 1763 dev_kfree_skb (skb); 1762 1764 np->rx_skbuff[i] = NULL; 1763 1765 } 1766 + np->rx_ring[i].status = 0; 1767 + np->rx_ring[i].fraginfo = 0; 1764 1768 } 1765 1769 for (i = 0; i < TX_RING_SIZE; i++) { 1766 1770 skb = np->tx_skbuff[i];
+1 -1
drivers/net/enc28j60.c
··· 812 812 if (netif_msg_hw(priv)) 813 813 printk(KERN_DEBUG DRV_NAME ": reading TSV at addr:0x%04x\n", 814 814 endptr + 1); 815 - enc28j60_mem_read(priv, endptr + 1, sizeof(tsv), tsv); 815 + enc28j60_mem_read(priv, endptr + 1, TSV_SIZE, tsv); 816 816 } 817 817 818 818 static void enc28j60_dump_tsv(struct enc28j60_net *priv, const char *msg,
+45 -16
drivers/net/niu.c
··· 4489 4489 { 4490 4490 struct niu_parent *parent = np->parent; 4491 4491 int first_rx_channel, first_tx_channel; 4492 + int num_rx_rings, num_tx_rings; 4493 + struct rx_ring_info *rx_rings; 4494 + struct tx_ring_info *tx_rings; 4492 4495 int i, port, err; 4493 4496 4494 4497 port = np->port; ··· 4501 4498 first_tx_channel += parent->txchan_per_port[i]; 4502 4499 } 4503 4500 4504 - np->num_rx_rings = parent->rxchan_per_port[port]; 4505 - np->num_tx_rings = parent->txchan_per_port[port]; 4501 + num_rx_rings = parent->rxchan_per_port[port]; 4502 + num_tx_rings = parent->txchan_per_port[port]; 4506 4503 4507 - netif_set_real_num_rx_queues(np->dev, np->num_rx_rings); 4508 - netif_set_real_num_tx_queues(np->dev, np->num_tx_rings); 4509 - 4510 - np->rx_rings = kcalloc(np->num_rx_rings, sizeof(struct rx_ring_info), 4511 - GFP_KERNEL); 4504 + rx_rings = kcalloc(num_rx_rings, sizeof(struct rx_ring_info), 4505 + GFP_KERNEL); 4512 4506 err = -ENOMEM; 4513 - if (!np->rx_rings) 4507 + if (!rx_rings) 4514 4508 goto out_err; 4509 + 4510 + np->num_rx_rings = num_rx_rings; 4511 + smp_wmb(); 4512 + np->rx_rings = rx_rings; 4513 + 4514 + netif_set_real_num_rx_queues(np->dev, num_rx_rings); 4515 4515 4516 4516 for (i = 0; i < np->num_rx_rings; i++) { 4517 4517 struct rx_ring_info *rp = &np->rx_rings[i]; ··· 4544 4538 return err; 4545 4539 } 4546 4540 4547 - np->tx_rings = kcalloc(np->num_tx_rings, sizeof(struct tx_ring_info), 4548 - GFP_KERNEL); 4541 + tx_rings = kcalloc(num_tx_rings, sizeof(struct tx_ring_info), 4542 + GFP_KERNEL); 4549 4543 err = -ENOMEM; 4550 - if (!np->tx_rings) 4544 + if (!tx_rings) 4551 4545 goto out_err; 4546 + 4547 + np->num_tx_rings = num_tx_rings; 4548 + smp_wmb(); 4549 + np->tx_rings = tx_rings; 4550 + 4551 + netif_set_real_num_tx_queues(np->dev, num_tx_rings); 4552 4552 4553 4553 for (i = 0; i < np->num_tx_rings; i++) { 4554 4554 struct tx_ring_info *rp = &np->tx_rings[i]; ··· 6258 6246 static void niu_get_rx_stats(struct niu *np) 6259 6247 { 6260 6248 unsigned long pkts, dropped, errors, bytes; 6249 + struct rx_ring_info *rx_rings; 6261 6250 int i; 6262 6251 6263 6252 pkts = dropped = errors = bytes = 0; 6253 + 6254 + rx_rings = ACCESS_ONCE(np->rx_rings); 6255 + if (!rx_rings) 6256 + goto no_rings; 6257 + 6264 6258 for (i = 0; i < np->num_rx_rings; i++) { 6265 - struct rx_ring_info *rp = &np->rx_rings[i]; 6259 + struct rx_ring_info *rp = &rx_rings[i]; 6266 6260 6267 6261 niu_sync_rx_discard_stats(np, rp, 0); 6268 6262 ··· 6277 6259 dropped += rp->rx_dropped; 6278 6260 errors += rp->rx_errors; 6279 6261 } 6262 + 6263 + no_rings: 6280 6264 np->dev->stats.rx_packets = pkts; 6281 6265 np->dev->stats.rx_bytes = bytes; 6282 6266 np->dev->stats.rx_dropped = dropped; ··· 6288 6268 static void niu_get_tx_stats(struct niu *np) 6289 6269 { 6290 6270 unsigned long pkts, errors, bytes; 6271 + struct tx_ring_info *tx_rings; 6291 6272 int i; 6292 6273 6293 6274 pkts = errors = bytes = 0; 6275 + 6276 + tx_rings = ACCESS_ONCE(np->tx_rings); 6277 + if (!tx_rings) 6278 + goto no_rings; 6279 + 6294 6280 for (i = 0; i < np->num_tx_rings; i++) { 6295 - struct tx_ring_info *rp = &np->tx_rings[i]; 6281 + struct tx_ring_info *rp = &tx_rings[i]; 6296 6282 6297 6283 pkts += rp->tx_packets; 6298 6284 bytes += rp->tx_bytes; 6299 6285 errors += rp->tx_errors; 6300 6286 } 6287 + 6288 + no_rings: 6301 6289 np->dev->stats.tx_packets = pkts; 6302 6290 np->dev->stats.tx_bytes = bytes; 6303 6291 np->dev->stats.tx_errors = errors; ··· 6315 6287 { 6316 6288 struct niu *np = netdev_priv(dev); 6317 6289 6318 - niu_get_rx_stats(np); 6319 - niu_get_tx_stats(np); 6320 - 6290 + if (netif_running(dev)) { 6291 + niu_get_rx_stats(np); 6292 + niu_get_tx_stats(np); 6293 + } 6321 6294 return &dev->stats; 6322 6295 } 6323 6296
+2 -4
drivers/net/pcmcia/axnet_cs.c
··· 1488 1488 1489 1489 /* 1490 1490 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total. 1491 - * Early datasheets said to poll the reset bit, but now they say that 1492 - * it "is not a reliable indicator and subsequently should be ignored." 1493 - * We wait at least 10ms. 1491 + * We wait at least 2ms. 1494 1492 */ 1495 1493 1496 - mdelay(10); 1494 + mdelay(2); 1497 1495 1498 1496 /* 1499 1497 * Reset RBCR[01] back to zero as per magic incantation.
+32 -9
drivers/net/r8169.c
··· 973 973 if (pm) 974 974 pm_request_resume(&tp->pci_dev->dev); 975 975 netif_carrier_on(dev); 976 - netif_info(tp, ifup, dev, "link up\n"); 976 + if (net_ratelimit()) 977 + netif_info(tp, ifup, dev, "link up\n"); 977 978 } else { 978 979 netif_carrier_off(dev); 979 980 netif_info(tp, ifdown, dev, "link down\n"); ··· 3758 3757 RTL_W16(IntrMitigate, 0x5151); 3759 3758 3760 3759 /* Work around for RxFIFO overflow. */ 3761 - if (tp->mac_version == RTL_GIGA_MAC_VER_11) { 3760 + if (tp->mac_version == RTL_GIGA_MAC_VER_11 || 3761 + tp->mac_version == RTL_GIGA_MAC_VER_22) { 3762 3762 tp->intr_event |= RxFIFOOver | PCSTimeout; 3763 3763 tp->intr_event &= ~RxOverflow; 3764 3764 } ··· 4641 4639 break; 4642 4640 } 4643 4641 4644 - /* Work around for rx fifo overflow */ 4645 - if (unlikely(status & RxFIFOOver) && 4646 - (tp->mac_version == RTL_GIGA_MAC_VER_11)) { 4647 - netif_stop_queue(dev); 4648 - rtl8169_tx_timeout(dev); 4649 - break; 4642 + if (unlikely(status & RxFIFOOver)) { 4643 + switch (tp->mac_version) { 4644 + /* Work around for rx fifo overflow */ 4645 + case RTL_GIGA_MAC_VER_11: 4646 + case RTL_GIGA_MAC_VER_22: 4647 + case RTL_GIGA_MAC_VER_26: 4648 + netif_stop_queue(dev); 4649 + rtl8169_tx_timeout(dev); 4650 + goto done; 4651 + /* Testers needed. */ 4652 + case RTL_GIGA_MAC_VER_17: 4653 + case RTL_GIGA_MAC_VER_19: 4654 + case RTL_GIGA_MAC_VER_20: 4655 + case RTL_GIGA_MAC_VER_21: 4656 + case RTL_GIGA_MAC_VER_23: 4657 + case RTL_GIGA_MAC_VER_24: 4658 + case RTL_GIGA_MAC_VER_27: 4659 + case RTL_GIGA_MAC_VER_28: 4660 + /* Experimental science. Pktgen proof. */ 4661 + case RTL_GIGA_MAC_VER_12: 4662 + case RTL_GIGA_MAC_VER_25: 4663 + if (status == RxFIFOOver) 4664 + goto done; 4665 + break; 4666 + default: 4667 + break; 4668 + } 4650 4669 } 4651 4670 4652 4671 if (unlikely(status & SYSErr)) { ··· 4703 4680 (status & RxFIFOOver) ? (status | RxOverflow) : status); 4704 4681 status = RTL_R16(IntrStatus); 4705 4682 } 4706 - 4683 + done: 4707 4684 return IRQ_RETVAL(handled); 4708 4685 } 4709 4686
+1 -1
drivers/net/vxge/vxge-config.c
··· 3690 3690 if (status != VXGE_HW_OK) 3691 3691 goto exit; 3692 3692 3693 - if ((rts_table != VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) || 3693 + if ((rts_table != VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) && 3694 3694 (rts_table != 3695 3695 VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT)) 3696 3696 *data1 = 0;
+2 -2
drivers/net/wireless/ath/ath5k/dma.c
··· 838 838 for (i = 0; i < qmax; i++) { 839 839 err = ath5k_hw_stop_tx_dma(ah, i); 840 840 /* -EINVAL -> queue inactive */ 841 - if (err != -EINVAL) 841 + if (err && err != -EINVAL) 842 842 return err; 843 843 } 844 844 845 - return err; 845 + return 0; 846 846 }
+1 -3
drivers/net/wireless/ath/ath5k/pcu.c
··· 86 86 if (!ah->ah_bwmode) { 87 87 dur = ieee80211_generic_frame_duration(sc->hw, 88 88 NULL, len, rate); 89 - return dur; 89 + return le16_to_cpu(dur); 90 90 } 91 91 92 92 bitrate = rate->bitrate; ··· 264 264 * ieee80211_duration() for a brief description of 265 265 * what rate we should choose to TX ACKs. */ 266 266 tx_time = ath5k_hw_get_frame_duration(ah, 10, rate); 267 - 268 - tx_time = le16_to_cpu(tx_time); 269 267 270 268 ath5k_hw_reg_write(ah, tx_time, reg); 271 269
+1 -2
drivers/net/wireless/ath/ath9k/ar9002_hw.c
··· 426 426 } 427 427 428 428 /* WAR for ASPM system hang */ 429 - if (AR_SREV_9280(ah) || AR_SREV_9285(ah) || AR_SREV_9287(ah)) { 429 + if (AR_SREV_9285(ah) || AR_SREV_9287(ah)) 430 430 val |= (AR_WA_BIT6 | AR_WA_BIT7); 431 - } 432 431 433 432 if (AR_SREV_9285E_20(ah)) 434 433 val |= AR_WA_BIT23;
-3
drivers/net/wireless/ath/ath9k/htc_drv_init.c
··· 142 142 { 143 143 ath9k_htc_exit_debug(priv->ah); 144 144 ath9k_hw_deinit(priv->ah); 145 - tasklet_kill(&priv->swba_tasklet); 146 - tasklet_kill(&priv->rx_tasklet); 147 - tasklet_kill(&priv->tx_tasklet); 148 145 kfree(priv->ah); 149 146 priv->ah = NULL; 150 147 }
+15 -6
drivers/net/wireless/ath/ath9k/htc_drv_main.c
··· 1025 1025 int ret = 0; 1026 1026 u8 cmd_rsp; 1027 1027 1028 - /* Cancel all the running timers/work .. */ 1029 - cancel_work_sync(&priv->fatal_work); 1030 - cancel_work_sync(&priv->ps_work); 1031 - cancel_delayed_work_sync(&priv->ath9k_led_blink_work); 1032 - ath9k_led_stop_brightness(priv); 1033 - 1034 1028 mutex_lock(&priv->mutex); 1035 1029 1036 1030 if (priv->op_flags & OP_INVALID) { ··· 1038 1044 WMI_CMD(WMI_DISABLE_INTR_CMDID); 1039 1045 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID); 1040 1046 WMI_CMD(WMI_STOP_RECV_CMDID); 1047 + 1048 + tasklet_kill(&priv->swba_tasklet); 1049 + tasklet_kill(&priv->rx_tasklet); 1050 + tasklet_kill(&priv->tx_tasklet); 1051 + 1041 1052 skb_queue_purge(&priv->tx_queue); 1053 + 1054 + mutex_unlock(&priv->mutex); 1055 + 1056 + /* Cancel all the running timers/work .. */ 1057 + cancel_work_sync(&priv->fatal_work); 1058 + cancel_work_sync(&priv->ps_work); 1059 + cancel_delayed_work_sync(&priv->ath9k_led_blink_work); 1060 + ath9k_led_stop_brightness(priv); 1061 + 1062 + mutex_lock(&priv->mutex); 1042 1063 1043 1064 /* Remove monitor interface here */ 1044 1065 if (ah->opmode == NL80211_IFTYPE_MONITOR) {
+2 -5
drivers/net/wireless/ath/ath9k/init.c
··· 598 598 err_queues: 599 599 ath9k_hw_deinit(ah); 600 600 err_hw: 601 - tasklet_kill(&sc->intr_tq); 602 - tasklet_kill(&sc->bcon_tasklet); 603 601 604 602 kfree(ah); 605 603 sc->sc_ah = NULL; ··· 805 807 806 808 ath9k_hw_deinit(sc->sc_ah); 807 809 808 - tasklet_kill(&sc->intr_tq); 809 - tasklet_kill(&sc->bcon_tasklet); 810 - 811 810 kfree(sc->sc_ah); 812 811 sc->sc_ah = NULL; 813 812 } ··· 818 823 819 824 wiphy_rfkill_stop_polling(sc->hw->wiphy); 820 825 ath_deinit_leds(sc); 826 + 827 + ath9k_ps_restore(sc); 821 828 822 829 for (i = 0; i < sc->num_sec_wiphy; i++) { 823 830 struct ath_wiphy *aphy = sc->sec_wiphy[i];
+16 -3
drivers/net/wireless/ath/ath9k/main.c
··· 325 325 { 326 326 struct ieee80211_hw *hw = sc->hw; 327 327 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 328 + struct ath_hw *ah = sc->sc_ah; 329 + struct ath_common *common = ath9k_hw_common(ah); 328 330 struct ath_tx_control txctl; 329 331 int time_left; 330 332 ··· 344 342 init_completion(&sc->paprd_complete); 345 343 sc->paprd_pending = true; 346 344 txctl.paprd = BIT(chain); 347 - if (ath_tx_start(hw, skb, &txctl) != 0) 345 + 346 + if (ath_tx_start(hw, skb, &txctl) != 0) { 347 + ath_dbg(common, ATH_DBG_XMIT, "PAPRD TX failed\n"); 348 + dev_kfree_skb_any(skb); 348 349 return false; 350 + } 349 351 350 352 time_left = wait_for_completion_timeout(&sc->paprd_complete, 351 353 msecs_to_jiffies(ATH_PAPRD_TIMEOUT)); ··· 959 953 960 954 spin_unlock_bh(&sc->sc_pcu_lock); 961 955 ath9k_ps_restore(sc); 962 - 963 - ath9k_setpower(sc, ATH9K_PM_FULL_SLEEP); 964 956 } 965 957 966 958 int ath_reset(struct ath_softc *sc, bool retry_tx) ··· 1313 1309 1314 1310 spin_lock_bh(&sc->sc_pcu_lock); 1315 1311 1312 + /* prevent tasklets to enable interrupts once we disable them */ 1313 + ah->imask &= ~ATH9K_INT_GLOBAL; 1314 + 1316 1315 /* make sure h/w will not generate any interrupt 1317 1316 * before setting the invalid flag. */ 1318 1317 ath9k_hw_disable_interrupts(ah); ··· 1332 1325 ath9k_hw_configpcipowersave(ah, 1, 1); 1333 1326 1334 1327 spin_unlock_bh(&sc->sc_pcu_lock); 1328 + 1329 + /* we can now sync irq and kill any running tasklets, since we already 1330 + * disabled interrupts and not holding a spin lock */ 1331 + synchronize_irq(sc->irq); 1332 + tasklet_kill(&sc->intr_tq); 1333 + tasklet_kill(&sc->bcon_tasklet); 1335 1334 1336 1335 ath9k_ps_restore(sc); 1337 1336
+20 -20
drivers/net/wireless/rtlwifi/efuse.c
··· 726 726 } 727 727 728 728 static void efuse_write_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr, 729 - u8 efuse_data, u8 offset, int *bcontinual, 730 - u8 *write_state, struct pgpkt_struct target_pkt, 731 - int *repeat_times, int *bresult, u8 word_en) 729 + u8 efuse_data, u8 offset, int *bcontinual, 730 + u8 *write_state, struct pgpkt_struct *target_pkt, 731 + int *repeat_times, int *bresult, u8 word_en) 732 732 { 733 733 struct rtl_priv *rtlpriv = rtl_priv(hw); 734 734 struct pgpkt_struct tmp_pkt; ··· 744 744 tmp_pkt.word_en = tmp_header & 0x0F; 745 745 tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en); 746 746 747 - if (tmp_pkt.offset != target_pkt.offset) { 748 - efuse_addr = efuse_addr + (tmp_word_cnts * 2) + 1; 747 + if (tmp_pkt.offset != target_pkt->offset) { 748 + *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1; 749 749 *write_state = PG_STATE_HEADER; 750 750 } else { 751 751 for (tmpindex = 0; tmpindex < (tmp_word_cnts * 2); tmpindex++) { ··· 756 756 } 757 757 758 758 if (bdataempty == false) { 759 - efuse_addr = efuse_addr + (tmp_word_cnts * 2) + 1; 759 + *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1; 760 760 *write_state = PG_STATE_HEADER; 761 761 } else { 762 762 match_word_en = 0x0F; 763 - if (!((target_pkt.word_en & BIT(0)) | 763 + if (!((target_pkt->word_en & BIT(0)) | 764 764 (tmp_pkt.word_en & BIT(0)))) 765 765 match_word_en &= (~BIT(0)); 766 766 767 - if (!((target_pkt.word_en & BIT(1)) | 767 + if (!((target_pkt->word_en & BIT(1)) | 768 768 (tmp_pkt.word_en & BIT(1)))) 769 769 match_word_en &= (~BIT(1)); 770 770 771 - if (!((target_pkt.word_en & BIT(2)) | 771 + if (!((target_pkt->word_en & BIT(2)) | 772 772 (tmp_pkt.word_en & BIT(2)))) 773 773 match_word_en &= (~BIT(2)); 774 774 775 - if (!((target_pkt.word_en & BIT(3)) | 775 + if (!((target_pkt->word_en & BIT(3)) | 776 776 (tmp_pkt.word_en & BIT(3)))) 777 777 match_word_en &= (~BIT(3)); 778 778 ··· 780 780 badworden = efuse_word_enable_data_write( 781 781 hw, *efuse_addr + 1, 782 782 tmp_pkt.word_en, 783 - target_pkt.data); 783 + target_pkt->data); 784 784 785 785 if (0x0F != (badworden & 0x0F)) { 786 786 u8 reorg_offset = offset; ··· 791 791 } 792 792 793 793 tmp_word_en = 0x0F; 794 - if ((target_pkt.word_en & BIT(0)) ^ 794 + if ((target_pkt->word_en & BIT(0)) ^ 795 795 (match_word_en & BIT(0))) 796 796 tmp_word_en &= (~BIT(0)); 797 797 798 - if ((target_pkt.word_en & BIT(1)) ^ 798 + if ((target_pkt->word_en & BIT(1)) ^ 799 799 (match_word_en & BIT(1))) 800 800 tmp_word_en &= (~BIT(1)); 801 801 802 - if ((target_pkt.word_en & BIT(2)) ^ 802 + if ((target_pkt->word_en & BIT(2)) ^ 803 803 (match_word_en & BIT(2))) 804 804 tmp_word_en &= (~BIT(2)); 805 805 806 - if ((target_pkt.word_en & BIT(3)) ^ 806 + if ((target_pkt->word_en & BIT(3)) ^ 807 807 (match_word_en & BIT(3))) 808 808 tmp_word_en &= (~BIT(3)); 809 809 810 810 if ((tmp_word_en & 0x0F) != 0x0F) { 811 811 *efuse_addr = efuse_get_current_size(hw); 812 - target_pkt.offset = offset; 813 - target_pkt.word_en = tmp_word_en; 812 + target_pkt->offset = offset; 813 + target_pkt->word_en = tmp_word_en; 814 814 } else 815 815 *bcontinual = false; 816 816 *write_state = PG_STATE_HEADER; ··· 821 821 } 822 822 } else { 823 823 *efuse_addr += (2 * tmp_word_cnts) + 1; 824 - target_pkt.offset = offset; 825 - target_pkt.word_en = word_en; 824 + target_pkt->offset = offset; 825 + target_pkt->word_en = word_en; 826 826 *write_state = PG_STATE_HEADER; 827 827 } 828 828 } ··· 938 938 efuse_write_data_case1(hw, &efuse_addr, 939 939 efuse_data, offset, 940 940 &bcontinual, 941 - &write_state, target_pkt, 941 + &write_state, &target_pkt, 942 942 &repeat_times, &bresult, 943 943 word_en); 944 944 else
+1 -2
drivers/net/wireless/wl12xx/spi.c
··· 110 110 spi_message_add_tail(&t, &m); 111 111 112 112 spi_sync(wl_to_spi(wl), &m); 113 - kfree(cmd); 114 - 115 113 wl1271_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN); 114 + kfree(cmd); 116 115 } 117 116 118 117 static void wl1271_spi_init(struct wl1271 *wl)
+88 -8
drivers/net/xen-netfront.c
··· 120 120 unsigned long rx_pfn_array[NET_RX_RING_SIZE]; 121 121 struct multicall_entry rx_mcl[NET_RX_RING_SIZE+1]; 122 122 struct mmu_update rx_mmu[NET_RX_RING_SIZE]; 123 + 124 + /* Statistics */ 125 + int rx_gso_checksum_fixup; 123 126 }; 124 127 125 128 struct netfront_rx_info { ··· 773 770 return cons; 774 771 } 775 772 776 - static int skb_checksum_setup(struct sk_buff *skb) 773 + static int checksum_setup(struct net_device *dev, struct sk_buff *skb) 777 774 { 778 775 struct iphdr *iph; 779 776 unsigned char *th; 780 777 int err = -EPROTO; 778 + int recalculate_partial_csum = 0; 779 + 780 + /* 781 + * A GSO SKB must be CHECKSUM_PARTIAL. However some buggy 782 + * peers can fail to set NETRXF_csum_blank when sending a GSO 783 + * frame. In this case force the SKB to CHECKSUM_PARTIAL and 784 + * recalculate the partial checksum. 785 + */ 786 + if (skb->ip_summed != CHECKSUM_PARTIAL && skb_is_gso(skb)) { 787 + struct netfront_info *np = netdev_priv(dev); 788 + np->rx_gso_checksum_fixup++; 789 + skb->ip_summed = CHECKSUM_PARTIAL; 790 + recalculate_partial_csum = 1; 791 + } 792 + 793 + /* A non-CHECKSUM_PARTIAL SKB does not require setup. */ 794 + if (skb->ip_summed != CHECKSUM_PARTIAL) 795 + return 0; 781 796 782 797 if (skb->protocol != htons(ETH_P_IP)) 783 798 goto out; ··· 809 788 switch (iph->protocol) { 810 789 case IPPROTO_TCP: 811 790 skb->csum_offset = offsetof(struct tcphdr, check); 791 + 792 + if (recalculate_partial_csum) { 793 + struct tcphdr *tcph = (struct tcphdr *)th; 794 + tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, 795 + skb->len - iph->ihl*4, 796 + IPPROTO_TCP, 0); 797 + } 812 798 break; 813 799 case IPPROTO_UDP: 814 800 skb->csum_offset = offsetof(struct udphdr, check); 801 + 802 + if (recalculate_partial_csum) { 803 + struct udphdr *udph = (struct udphdr *)th; 804 + udph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, 805 + skb->len - iph->ihl*4, 806 + IPPROTO_UDP, 0); 807 + } 815 808 break; 816 809 default: 817 810 if (net_ratelimit()) ··· 864 829 /* Ethernet work: Delayed to here as it peeks the header. */ 865 830 skb->protocol = eth_type_trans(skb, dev); 866 831 867 - if (skb->ip_summed == CHECKSUM_PARTIAL) { 868 - if (skb_checksum_setup(skb)) { 869 - kfree_skb(skb); 870 - packets_dropped++; 871 - dev->stats.rx_errors++; 872 - continue; 873 - } 832 + if (checksum_setup(dev, skb)) { 833 + kfree_skb(skb); 834 + packets_dropped++; 835 + dev->stats.rx_errors++; 836 + continue; 874 837 } 875 838 876 839 dev->stats.rx_packets++; ··· 1665 1632 } 1666 1633 } 1667 1634 1635 + static const struct xennet_stat { 1636 + char name[ETH_GSTRING_LEN]; 1637 + u16 offset; 1638 + } xennet_stats[] = { 1639 + { 1640 + "rx_gso_checksum_fixup", 1641 + offsetof(struct netfront_info, rx_gso_checksum_fixup) 1642 + }, 1643 + }; 1644 + 1645 + static int xennet_get_sset_count(struct net_device *dev, int string_set) 1646 + { 1647 + switch (string_set) { 1648 + case ETH_SS_STATS: 1649 + return ARRAY_SIZE(xennet_stats); 1650 + default: 1651 + return -EINVAL; 1652 + } 1653 + } 1654 + 1655 + static void xennet_get_ethtool_stats(struct net_device *dev, 1656 + struct ethtool_stats *stats, u64 * data) 1657 + { 1658 + void *np = netdev_priv(dev); 1659 + int i; 1660 + 1661 + for (i = 0; i < ARRAY_SIZE(xennet_stats); i++) 1662 + data[i] = *(int *)(np + xennet_stats[i].offset); 1663 + } 1664 + 1665 + static void xennet_get_strings(struct net_device *dev, u32 stringset, u8 * data) 1666 + { 1667 + int i; 1668 + 1669 + switch (stringset) { 1670 + case ETH_SS_STATS: 1671 + for (i = 0; i < ARRAY_SIZE(xennet_stats); i++) 1672 + memcpy(data + i * ETH_GSTRING_LEN, 1673 + xennet_stats[i].name, ETH_GSTRING_LEN); 1674 + break; 1675 + } 1676 + } 1677 + 1668 1678 static const struct ethtool_ops xennet_ethtool_ops = 1669 1679 { 1670 1680 .set_tx_csum = ethtool_op_set_tx_csum, 1671 1681 .set_sg = xennet_set_sg, 1672 1682 .set_tso = xennet_set_tso, 1673 1683 .get_link = ethtool_op_get_link, 1684 + 1685 + .get_sset_count = xennet_get_sset_count, 1686 + .get_ethtool_stats = xennet_get_ethtool_stats, 1687 + .get_strings = xennet_get_strings, 1674 1688 }; 1675 1689 1676 1690 #ifdef CONFIG_SYSFS
+1 -1
drivers/s390/net/netiucv.c
··· 565 565 struct iucv_event ev; 566 566 int rc; 567 567 568 - if (memcmp(iucvMagic, ipuser, sizeof(ipuser))) 568 + if (memcmp(iucvMagic, ipuser, 16)) 569 569 /* ipuser must match iucvMagic. */ 570 570 return -EINVAL; 571 571 rc = -EINVAL;
+76 -73
drivers/s390/net/qeth_core_main.c
··· 988 988 chp_dsc = (struct channelPath_dsc *)ccw_device_get_chp_desc(ccwdev, 0); 989 989 if (chp_dsc != NULL) { 990 990 /* CHPP field bit 6 == 1 -> single queue */ 991 - if ((chp_dsc->chpp & 0x02) == 0x02) 991 + if ((chp_dsc->chpp & 0x02) == 0x02) { 992 + if ((atomic_read(&card->qdio.state) != 993 + QETH_QDIO_UNINITIALIZED) && 994 + (card->qdio.no_out_queues == 4)) 995 + /* change from 4 to 1 outbound queues */ 996 + qeth_free_qdio_buffers(card); 992 997 card->qdio.no_out_queues = 1; 998 + if (card->qdio.default_out_queue != 0) 999 + dev_info(&card->gdev->dev, 1000 + "Priority Queueing not supported\n"); 1001 + card->qdio.default_out_queue = 0; 1002 + } else { 1003 + if ((atomic_read(&card->qdio.state) != 1004 + QETH_QDIO_UNINITIALIZED) && 1005 + (card->qdio.no_out_queues == 1)) { 1006 + /* change from 1 to 4 outbound queues */ 1007 + qeth_free_qdio_buffers(card); 1008 + card->qdio.default_out_queue = 2; 1009 + } 1010 + card->qdio.no_out_queues = 4; 1011 + } 993 1012 card->info.func_level = 0x4100 + chp_dsc->desc; 994 1013 kfree(chp_dsc); 995 - } 996 - if (card->qdio.no_out_queues == 1) { 997 - card->qdio.default_out_queue = 0; 998 - dev_info(&card->gdev->dev, 999 - "Priority Queueing not supported\n"); 1000 1014 } 1001 1015 QETH_DBF_TEXT_(SETUP, 2, "nr:%x", card->qdio.no_out_queues); 1002 1016 QETH_DBF_TEXT_(SETUP, 2, "lvl:%02x", card->info.func_level); ··· 1846 1832 } 1847 1833 } 1848 1834 1849 - static inline int qeth_get_max_mtu_for_card(int cardtype) 1850 - { 1851 - switch (cardtype) { 1852 - 1853 - case QETH_CARD_TYPE_UNKNOWN: 1854 - case QETH_CARD_TYPE_OSD: 1855 - case QETH_CARD_TYPE_OSN: 1856 - case QETH_CARD_TYPE_OSM: 1857 - case QETH_CARD_TYPE_OSX: 1858 - return 61440; 1859 - case QETH_CARD_TYPE_IQD: 1860 - return 57344; 1861 - default: 1862 - return 1500; 1863 - } 1864 - } 1865 - 1866 - static inline int qeth_get_mtu_out_of_mpc(int cardtype) 1867 - { 1868 - switch (cardtype) { 1869 - case QETH_CARD_TYPE_IQD: 1870 - return 1; 1871 - default: 1872 - return 0; 1873 - } 1874 - } 1875 - 1876 1835 static inline int qeth_get_mtu_outof_framesize(int framesize) 1877 1836 { 1878 1837 switch (framesize) { ··· 1868 1881 case QETH_CARD_TYPE_OSD: 1869 1882 case QETH_CARD_TYPE_OSM: 1870 1883 case QETH_CARD_TYPE_OSX: 1871 - return ((mtu >= 576) && (mtu <= 61440)); 1872 1884 case QETH_CARD_TYPE_IQD: 1873 1885 return ((mtu >= 576) && 1874 - (mtu <= card->info.max_mtu + 4096 - 32)); 1886 + (mtu <= card->info.max_mtu)); 1875 1887 case QETH_CARD_TYPE_OSN: 1876 1888 case QETH_CARD_TYPE_UNKNOWN: 1877 1889 default: ··· 1893 1907 memcpy(&card->token.ulp_filter_r, 1894 1908 QETH_ULP_ENABLE_RESP_FILTER_TOKEN(iob->data), 1895 1909 QETH_MPC_TOKEN_LENGTH); 1896 - if (qeth_get_mtu_out_of_mpc(card->info.type)) { 1910 + if (card->info.type == QETH_CARD_TYPE_IQD) { 1897 1911 memcpy(&framesize, QETH_ULP_ENABLE_RESP_MAX_MTU(iob->data), 2); 1898 1912 mtu = qeth_get_mtu_outof_framesize(framesize); 1899 1913 if (!mtu) { ··· 1901 1915 QETH_DBF_TEXT_(SETUP, 2, " rc%d", iob->rc); 1902 1916 return 0; 1903 1917 } 1904 - card->info.max_mtu = mtu; 1918 + if (card->info.initial_mtu && (card->info.initial_mtu != mtu)) { 1919 + /* frame size has changed */ 1920 + if (card->dev && 1921 + ((card->dev->mtu == card->info.initial_mtu) || 1922 + (card->dev->mtu > mtu))) 1923 + card->dev->mtu = mtu; 1924 + qeth_free_qdio_buffers(card); 1925 + } 1905 1926 card->info.initial_mtu = mtu; 1927 + card->info.max_mtu = mtu; 1906 1928 card->qdio.in_buf_size = mtu + 2 * PAGE_SIZE; 1907 1929 } else { 1908 1930 card->info.initial_mtu = qeth_get_initial_mtu_for_card(card); 1909 - card->info.max_mtu = qeth_get_max_mtu_for_card(card->info.type); 1931 + card->info.max_mtu = *(__u16 *)QETH_ULP_ENABLE_RESP_MAX_MTU( 1932 + iob->data); 1910 1933 card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT; 1911 1934 } 1912 1935 ··· 3770 3775 } 3771 3776 } 3772 3777 3778 + static void qeth_determine_capabilities(struct qeth_card *card) 3779 + { 3780 + int rc; 3781 + int length; 3782 + char *prcd; 3783 + struct ccw_device *ddev; 3784 + int ddev_offline = 0; 3785 + 3786 + QETH_DBF_TEXT(SETUP, 2, "detcapab"); 3787 + ddev = CARD_DDEV(card); 3788 + if (!ddev->online) { 3789 + ddev_offline = 1; 3790 + rc = ccw_device_set_online(ddev); 3791 + if (rc) { 3792 + QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 3793 + goto out; 3794 + } 3795 + } 3796 + 3797 + rc = qeth_read_conf_data(card, (void **) &prcd, &length); 3798 + if (rc) { 3799 + QETH_DBF_MESSAGE(2, "%s qeth_read_conf_data returned %i\n", 3800 + dev_name(&card->gdev->dev), rc); 3801 + QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 3802 + goto out_offline; 3803 + } 3804 + qeth_configure_unitaddr(card, prcd); 3805 + qeth_configure_blkt_default(card, prcd); 3806 + kfree(prcd); 3807 + 3808 + rc = qdio_get_ssqd_desc(ddev, &card->ssqd); 3809 + if (rc) 3810 + QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 3811 + 3812 + out_offline: 3813 + if (ddev_offline == 1) 3814 + ccw_device_set_offline(ddev); 3815 + out: 3816 + return; 3817 + } 3818 + 3773 3819 static int qeth_qdio_establish(struct qeth_card *card) 3774 3820 { 3775 3821 struct qdio_initialize init_data; ··· 3941 3905 3942 3906 QETH_DBF_TEXT(SETUP, 2, "hrdsetup"); 3943 3907 atomic_set(&card->force_alloc_skb, 0); 3908 + qeth_get_channel_path_desc(card); 3944 3909 retry: 3945 3910 if (retries) 3946 3911 QETH_DBF_MESSAGE(2, "%s Retrying to do IDX activates.\n", ··· 3970 3933 else 3971 3934 goto retry; 3972 3935 } 3936 + qeth_determine_capabilities(card); 3973 3937 qeth_init_tokens(card); 3974 3938 qeth_init_func_level(card); 3975 3939 rc = qeth_idx_activate_channel(&card->read, qeth_idx_read_cb); ··· 4238 4200 else 4239 4201 symbol_put(qeth_l3_ccwgroup_driver); 4240 4202 card->discipline.ccwgdriver = NULL; 4241 - } 4242 - 4243 - static void qeth_determine_capabilities(struct qeth_card *card) 4244 - { 4245 - int rc; 4246 - int length; 4247 - char *prcd; 4248 - 4249 - QETH_DBF_TEXT(SETUP, 2, "detcapab"); 4250 - rc = ccw_device_set_online(CARD_DDEV(card)); 4251 - if (rc) { 4252 - QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 4253 - goto out; 4254 - } 4255 - 4256 - 4257 - rc = qeth_read_conf_data(card, (void **) &prcd, &length); 4258 - if (rc) { 4259 - QETH_DBF_MESSAGE(2, "%s qeth_read_conf_data returned %i\n", 4260 - dev_name(&card->gdev->dev), rc); 4261 - QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 4262 - goto out_offline; 4263 - } 4264 - qeth_configure_unitaddr(card, prcd); 4265 - qeth_configure_blkt_default(card, prcd); 4266 - kfree(prcd); 4267 - 4268 - rc = qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd); 4269 - if (rc) 4270 - QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 4271 - 4272 - out_offline: 4273 - ccw_device_set_offline(CARD_DDEV(card)); 4274 - out: 4275 - return; 4276 4203 } 4277 4204 4278 4205 static int qeth_core_probe_device(struct ccwgroup_device *gdev)
+2 -2
drivers/s390/net/qeth_l2_main.c
··· 573 573 case IPA_RC_L2_DUP_LAYER3_MAC: 574 574 dev_warn(&card->gdev->dev, 575 575 "MAC address %pM already exists\n", 576 - card->dev->dev_addr); 576 + cmd->data.setdelmac.mac); 577 577 break; 578 578 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP: 579 579 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP: 580 580 dev_warn(&card->gdev->dev, 581 581 "MAC address %pM is not authorized\n", 582 - card->dev->dev_addr); 582 + cmd->data.setdelmac.mac); 583 583 break; 584 584 default: 585 585 break;
+1 -1
drivers/s390/net/smsgiucv.c
··· 60 60 static int smsg_path_pending(struct iucv_path *path, u8 ipvmid[8], 61 61 u8 ipuser[16]) 62 62 { 63 - if (strncmp(ipvmid, "*MSG ", sizeof(ipvmid)) != 0) 63 + if (strncmp(ipvmid, "*MSG ", 8) != 0) 64 64 return -EINVAL; 65 65 /* Path pending from *MSG. */ 66 66 return iucv_path_accept(path, &smsg_handler, "SMSGIUCV ", NULL);
+5 -4
drivers/vhost/net.c
··· 128 128 size_t hdr_size; 129 129 struct socket *sock; 130 130 131 - /* TODO: check that we are running from vhost_worker? 132 - * Not sure it's worth it, it's straight-forward enough. */ 131 + /* TODO: check that we are running from vhost_worker? */ 133 132 sock = rcu_dereference_check(vq->private_data, 1); 134 133 if (!sock) 135 134 return; ··· 305 306 size_t len, total_len = 0; 306 307 int err; 307 308 size_t hdr_size; 308 - struct socket *sock = rcu_dereference(vq->private_data); 309 + /* TODO: check that we are running from vhost_worker? */ 310 + struct socket *sock = rcu_dereference_check(vq->private_data, 1); 309 311 if (!sock || skb_queue_empty(&sock->sk->sk_receive_queue)) 310 312 return; 311 313 ··· 415 415 int err, headcount; 416 416 size_t vhost_hlen, sock_hlen; 417 417 size_t vhost_len, sock_len; 418 - struct socket *sock = rcu_dereference(vq->private_data); 418 + /* TODO: check that we are running from vhost_worker? */ 419 + struct socket *sock = rcu_dereference_check(vq->private_data, 1); 419 420 if (!sock || skb_queue_empty(&sock->sk->sk_receive_queue)) 420 421 return; 421 422
+3 -3
drivers/vhost/vhost.h
··· 173 173 { 174 174 unsigned acked_features; 175 175 176 - acked_features = 177 - rcu_dereference_index_check(dev->acked_features, 178 - lockdep_is_held(&dev->mutex)); 176 + /* TODO: check that we are running from vhost_worker or dev mutex is 177 + * held? */ 178 + acked_features = rcu_dereference_index_check(dev->acked_features, 1); 179 179 return acked_features & (1 << bit); 180 180 } 181 181
+1
include/linux/Kbuild
··· 1 1 header-y += byteorder/ 2 2 header-y += can/ 3 + header-y += caif/ 3 4 header-y += dvb/ 4 5 header-y += hdlc/ 5 6 header-y += isdn/
+2
include/linux/caif/Kbuild
··· 1 + header-y += caif_socket.h 2 + header-y += if_caif.h
+1
include/linux/mroute.h
··· 150 150 extern int ip_mroute_setsockopt(struct sock *, int, char __user *, unsigned int); 151 151 extern int ip_mroute_getsockopt(struct sock *, int, char __user *, int __user *); 152 152 extern int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg); 153 + extern int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg); 153 154 extern int ip_mr_init(void); 154 155 #else 155 156 static inline
+1
include/linux/mroute6.h
··· 136 136 extern int ip6_mroute_getsockopt(struct sock *, int, char __user *, int __user *); 137 137 extern int ip6_mr_input(struct sk_buff *skb); 138 138 extern int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg); 139 + extern int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg); 139 140 extern int ip6_mr_init(void); 140 141 extern void ip6_mr_cleanup(void); 141 142 #else
+2 -1
include/net/genetlink.h
··· 195 195 */ 196 196 static inline void genlmsg_cancel(struct sk_buff *skb, void *hdr) 197 197 { 198 - nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); 198 + if (hdr) 199 + nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); 199 200 } 200 201 201 202 /**
-3
include/net/netfilter/nf_conntrack_ecache.h
··· 77 77 if (e == NULL) 78 78 return; 79 79 80 - if (!(e->ctmask & (1 << event))) 81 - return; 82 - 83 80 set_bit(event, &e->cache); 84 81 } 85 82
+2
include/net/sock.h
··· 753 753 int level, 754 754 int optname, char __user *optval, 755 755 int __user *option); 756 + int (*compat_ioctl)(struct sock *sk, 757 + unsigned int cmd, unsigned long arg); 756 758 #endif 757 759 int (*sendmsg)(struct kiocb *iocb, struct sock *sk, 758 760 struct msghdr *msg, size_t len);
+8 -6
net/batman-adv/vis.c
··· 64 64 65 65 spin_unlock_bh(&bat_priv->vis_list_lock); 66 66 kfree_skb(info->skb_packet); 67 + kfree(info); 67 68 } 68 69 69 70 /* Compare two vis packets, used by the hashing algorithm */ ··· 269 268 buff_pos += sprintf(buff + buff_pos, "%pM,", 270 269 entry->addr); 271 270 272 - for (i = 0; i < packet->entries; i++) 271 + for (j = 0; j < packet->entries; j++) 273 272 buff_pos += vis_data_read_entry( 274 273 buff + buff_pos, 275 - &entries[i], 274 + &entries[j], 276 275 entry->addr, 277 276 entry->primary); 278 277 ··· 445 444 info); 446 445 if (hash_added < 0) { 447 446 /* did not work (for some reason) */ 448 - kref_put(&old_info->refcount, free_info); 447 + kref_put(&info->refcount, free_info); 449 448 info = NULL; 450 449 } 451 450 ··· 816 815 container_of(work, struct delayed_work, work); 817 816 struct bat_priv *bat_priv = 818 817 container_of(delayed_work, struct bat_priv, vis_work); 819 - struct vis_info *info, *temp; 818 + struct vis_info *info; 820 819 821 820 spin_lock_bh(&bat_priv->vis_hash_lock); 822 821 purge_vis_packets(bat_priv); ··· 826 825 send_list_add(bat_priv, bat_priv->my_vis_info); 827 826 } 828 827 829 - list_for_each_entry_safe(info, temp, &bat_priv->vis_send_list, 830 - send_list) { 828 + while (!list_empty(&bat_priv->vis_send_list)) { 829 + info = list_first_entry(&bat_priv->vis_send_list, 830 + typeof(*info), send_list); 831 831 832 832 kref_get(&info->refcount); 833 833 spin_unlock_bh(&bat_priv->vis_hash_lock);
+2 -2
net/bridge/br_fdb.c
··· 328 328 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC); 329 329 if (fdb) { 330 330 memcpy(fdb->addr.addr, addr, ETH_ALEN); 331 - hlist_add_head_rcu(&fdb->hlist, head); 332 - 333 331 fdb->dst = source; 334 332 fdb->is_local = is_local; 335 333 fdb->is_static = is_local; 336 334 fdb->ageing_timer = jiffies; 335 + 336 + hlist_add_head_rcu(&fdb->hlist, head); 337 337 } 338 338 return fdb; 339 339 }
+4 -1
net/core/dev.c
··· 2563 2563 2564 2564 map = rcu_dereference(rxqueue->rps_map); 2565 2565 if (map) { 2566 - if (map->len == 1) { 2566 + if (map->len == 1 && 2567 + !rcu_dereference_raw(rxqueue->rps_flow_table)) { 2567 2568 tcpu = map->cpus[0]; 2568 2569 if (cpu_online(tcpu)) 2569 2570 cpu = tcpu; ··· 3425 3424 __skb_pull(skb, skb_headlen(skb)); 3426 3425 skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb)); 3427 3426 skb->vlan_tci = 0; 3427 + skb->dev = napi->dev; 3428 + skb->skb_iif = 0; 3428 3429 3429 3430 napi->skb = skb; 3430 3431 }
+4 -2
net/core/rtnetlink.c
··· 1121 1121 return -EOPNOTSUPP; 1122 1122 1123 1123 if (af_ops->validate_link_af) { 1124 - err = af_ops->validate_link_af(dev, 1125 - tb[IFLA_AF_SPEC]); 1124 + err = af_ops->validate_link_af(dev, af); 1126 1125 if (err < 0) 1127 1126 return err; 1128 1127 } ··· 1671 1672 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind); 1672 1673 1673 1674 dest_net = rtnl_link_get_net(net, tb); 1675 + if (IS_ERR(dest_net)) 1676 + return PTR_ERR(dest_net); 1677 + 1674 1678 dev = rtnl_create_link(net, dest_net, ifname, ops, tb); 1675 1679 1676 1680 if (IS_ERR(dev))
+1
net/core/skbuff.c
··· 210 210 shinfo = skb_shinfo(skb); 211 211 memset(shinfo, 0, offsetof(struct skb_shared_info, dataref)); 212 212 atomic_set(&shinfo->dataref, 1); 213 + kmemcheck_annotate_variable(shinfo->destructor_arg); 213 214 214 215 if (fclone) { 215 216 struct sk_buff *child = skb + 1;
+2 -2
net/econet/af_econet.c
··· 265 265 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock, 266 266 struct msghdr *msg, size_t len) 267 267 { 268 - struct sock *sk = sock->sk; 269 268 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name; 270 269 struct net_device *dev; 271 270 struct ec_addr addr; 272 271 int err; 273 272 unsigned char port, cb; 274 273 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE) 274 + struct sock *sk = sock->sk; 275 275 struct sk_buff *skb; 276 276 struct ec_cb *eb; 277 277 #endif ··· 488 488 489 489 error_free_buf: 490 490 vfree(userbuf); 491 + error: 491 492 #else 492 493 err = -EPROTOTYPE; 493 494 #endif 494 - error: 495 495 mutex_unlock(&econet_mutex); 496 496 497 497 return err;
+16
net/ipv4/af_inet.c
··· 880 880 } 881 881 EXPORT_SYMBOL(inet_ioctl); 882 882 883 + #ifdef CONFIG_COMPAT 884 + int inet_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 885 + { 886 + struct sock *sk = sock->sk; 887 + int err = -ENOIOCTLCMD; 888 + 889 + if (sk->sk_prot->compat_ioctl) 890 + err = sk->sk_prot->compat_ioctl(sk, cmd, arg); 891 + 892 + return err; 893 + } 894 + #endif 895 + 883 896 const struct proto_ops inet_stream_ops = { 884 897 .family = PF_INET, 885 898 .owner = THIS_MODULE, ··· 916 903 #ifdef CONFIG_COMPAT 917 904 .compat_setsockopt = compat_sock_common_setsockopt, 918 905 .compat_getsockopt = compat_sock_common_getsockopt, 906 + .compat_ioctl = inet_compat_ioctl, 919 907 #endif 920 908 }; 921 909 EXPORT_SYMBOL(inet_stream_ops); ··· 943 929 #ifdef CONFIG_COMPAT 944 930 .compat_setsockopt = compat_sock_common_setsockopt, 945 931 .compat_getsockopt = compat_sock_common_getsockopt, 932 + .compat_ioctl = inet_compat_ioctl, 946 933 #endif 947 934 }; 948 935 EXPORT_SYMBOL(inet_dgram_ops); ··· 974 959 #ifdef CONFIG_COMPAT 975 960 .compat_setsockopt = compat_sock_common_setsockopt, 976 961 .compat_getsockopt = compat_sock_common_getsockopt, 962 + .compat_ioctl = inet_compat_ioctl, 977 963 #endif 978 964 }; 979 965
+76
net/ipv4/ipmr.c
··· 60 60 #include <linux/notifier.h> 61 61 #include <linux/if_arp.h> 62 62 #include <linux/netfilter_ipv4.h> 63 + #include <linux/compat.h> 63 64 #include <net/ipip.h> 64 65 #include <net/checksum.h> 65 66 #include <net/netlink.h> ··· 1434 1433 return -ENOIOCTLCMD; 1435 1434 } 1436 1435 } 1436 + 1437 + #ifdef CONFIG_COMPAT 1438 + struct compat_sioc_sg_req { 1439 + struct in_addr src; 1440 + struct in_addr grp; 1441 + compat_ulong_t pktcnt; 1442 + compat_ulong_t bytecnt; 1443 + compat_ulong_t wrong_if; 1444 + }; 1445 + 1446 + struct compat_sioc_vif_req { 1447 + vifi_t vifi; /* Which iface */ 1448 + compat_ulong_t icount; 1449 + compat_ulong_t ocount; 1450 + compat_ulong_t ibytes; 1451 + compat_ulong_t obytes; 1452 + }; 1453 + 1454 + int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg) 1455 + { 1456 + struct compat_sioc_sg_req sr; 1457 + struct compat_sioc_vif_req vr; 1458 + struct vif_device *vif; 1459 + struct mfc_cache *c; 1460 + struct net *net = sock_net(sk); 1461 + struct mr_table *mrt; 1462 + 1463 + mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT); 1464 + if (mrt == NULL) 1465 + return -ENOENT; 1466 + 1467 + switch (cmd) { 1468 + case SIOCGETVIFCNT: 1469 + if (copy_from_user(&vr, arg, sizeof(vr))) 1470 + return -EFAULT; 1471 + if (vr.vifi >= mrt->maxvif) 1472 + return -EINVAL; 1473 + read_lock(&mrt_lock); 1474 + vif = &mrt->vif_table[vr.vifi]; 1475 + if (VIF_EXISTS(mrt, vr.vifi)) { 1476 + vr.icount = vif->pkt_in; 1477 + vr.ocount = vif->pkt_out; 1478 + vr.ibytes = vif->bytes_in; 1479 + vr.obytes = vif->bytes_out; 1480 + read_unlock(&mrt_lock); 1481 + 1482 + if (copy_to_user(arg, &vr, sizeof(vr))) 1483 + return -EFAULT; 1484 + return 0; 1485 + } 1486 + read_unlock(&mrt_lock); 1487 + return -EADDRNOTAVAIL; 1488 + case SIOCGETSGCNT: 1489 + if (copy_from_user(&sr, arg, sizeof(sr))) 1490 + return -EFAULT; 1491 + 1492 + rcu_read_lock(); 1493 + c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr); 1494 + if (c) { 1495 + sr.pktcnt = c->mfc_un.res.pkt; 1496 + sr.bytecnt = c->mfc_un.res.bytes; 1497 + sr.wrong_if = c->mfc_un.res.wrong_if; 1498 + rcu_read_unlock(); 1499 + 1500 + if (copy_to_user(arg, &sr, sizeof(sr))) 1501 + return -EFAULT; 1502 + return 0; 1503 + } 1504 + rcu_read_unlock(); 1505 + return -EADDRNOTAVAIL; 1506 + default: 1507 + return -ENOIOCTLCMD; 1508 + } 1509 + } 1510 + #endif 1437 1511 1438 1512 1439 1513 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
+3 -3
net/ipv4/netfilter/arpt_mangle.c
··· 60 60 61 61 if (mangle->flags & ~ARPT_MANGLE_MASK || 62 62 !(mangle->flags & ARPT_MANGLE_MASK)) 63 - return false; 63 + return -EINVAL; 64 64 65 65 if (mangle->target != NF_DROP && mangle->target != NF_ACCEPT && 66 66 mangle->target != XT_CONTINUE) 67 - return false; 68 - return true; 67 + return -EINVAL; 68 + return 0; 69 69 } 70 70 71 71 static struct xt_target arpt_mangle_reg __read_mostly = {
+19
net/ipv4/raw.c
··· 76 76 #include <linux/seq_file.h> 77 77 #include <linux/netfilter.h> 78 78 #include <linux/netfilter_ipv4.h> 79 + #include <linux/compat.h> 79 80 80 81 static struct raw_hashinfo raw_v4_hashinfo = { 81 82 .lock = __RW_LOCK_UNLOCKED(raw_v4_hashinfo.lock), ··· 839 838 } 840 839 } 841 840 841 + #ifdef CONFIG_COMPAT 842 + static int compat_raw_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg) 843 + { 844 + switch (cmd) { 845 + case SIOCOUTQ: 846 + case SIOCINQ: 847 + return -ENOIOCTLCMD; 848 + default: 849 + #ifdef CONFIG_IP_MROUTE 850 + return ipmr_compat_ioctl(sk, cmd, compat_ptr(arg)); 851 + #else 852 + return -ENOIOCTLCMD; 853 + #endif 854 + } 855 + } 856 + #endif 857 + 842 858 struct proto raw_prot = { 843 859 .name = "RAW", 844 860 .owner = THIS_MODULE, ··· 878 860 #ifdef CONFIG_COMPAT 879 861 .compat_setsockopt = compat_raw_setsockopt, 880 862 .compat_getsockopt = compat_raw_getsockopt, 863 + .compat_ioctl = compat_raw_ioctl, 881 864 #endif 882 865 }; 883 866
+6
net/ipv4/route.c
··· 2707 2707 return NULL; 2708 2708 } 2709 2709 2710 + static unsigned int ipv4_blackhole_default_mtu(const struct dst_entry *dst) 2711 + { 2712 + return 0; 2713 + } 2714 + 2710 2715 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu) 2711 2716 { 2712 2717 } ··· 2721 2716 .protocol = cpu_to_be16(ETH_P_IP), 2722 2717 .destroy = ipv4_dst_destroy, 2723 2718 .check = ipv4_blackhole_dst_check, 2719 + .default_mtu = ipv4_blackhole_default_mtu, 2724 2720 .update_pmtu = ipv4_rt_blackhole_update_pmtu, 2725 2721 }; 2726 2722
+75
net/ipv6/ip6mr.c
··· 34 34 #include <linux/seq_file.h> 35 35 #include <linux/init.h> 36 36 #include <linux/slab.h> 37 + #include <linux/compat.h> 37 38 #include <net/protocol.h> 38 39 #include <linux/skbuff.h> 39 40 #include <net/sock.h> ··· 1805 1804 } 1806 1805 } 1807 1806 1807 + #ifdef CONFIG_COMPAT 1808 + struct compat_sioc_sg_req6 { 1809 + struct sockaddr_in6 src; 1810 + struct sockaddr_in6 grp; 1811 + compat_ulong_t pktcnt; 1812 + compat_ulong_t bytecnt; 1813 + compat_ulong_t wrong_if; 1814 + }; 1815 + 1816 + struct compat_sioc_mif_req6 { 1817 + mifi_t mifi; 1818 + compat_ulong_t icount; 1819 + compat_ulong_t ocount; 1820 + compat_ulong_t ibytes; 1821 + compat_ulong_t obytes; 1822 + }; 1823 + 1824 + int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg) 1825 + { 1826 + struct compat_sioc_sg_req6 sr; 1827 + struct compat_sioc_mif_req6 vr; 1828 + struct mif_device *vif; 1829 + struct mfc6_cache *c; 1830 + struct net *net = sock_net(sk); 1831 + struct mr6_table *mrt; 1832 + 1833 + mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT); 1834 + if (mrt == NULL) 1835 + return -ENOENT; 1836 + 1837 + switch (cmd) { 1838 + case SIOCGETMIFCNT_IN6: 1839 + if (copy_from_user(&vr, arg, sizeof(vr))) 1840 + return -EFAULT; 1841 + if (vr.mifi >= mrt->maxvif) 1842 + return -EINVAL; 1843 + read_lock(&mrt_lock); 1844 + vif = &mrt->vif6_table[vr.mifi]; 1845 + if (MIF_EXISTS(mrt, vr.mifi)) { 1846 + vr.icount = vif->pkt_in; 1847 + vr.ocount = vif->pkt_out; 1848 + vr.ibytes = vif->bytes_in; 1849 + vr.obytes = vif->bytes_out; 1850 + read_unlock(&mrt_lock); 1851 + 1852 + if (copy_to_user(arg, &vr, sizeof(vr))) 1853 + return -EFAULT; 1854 + return 0; 1855 + } 1856 + read_unlock(&mrt_lock); 1857 + return -EADDRNOTAVAIL; 1858 + case SIOCGETSGCNT_IN6: 1859 + if (copy_from_user(&sr, arg, sizeof(sr))) 1860 + return -EFAULT; 1861 + 1862 + read_lock(&mrt_lock); 1863 + c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr); 1864 + if (c) { 1865 + sr.pktcnt = c->mfc_un.res.pkt; 1866 + sr.bytecnt = c->mfc_un.res.bytes; 1867 + sr.wrong_if = c->mfc_un.res.wrong_if; 1868 + read_unlock(&mrt_lock); 1869 + 1870 + if (copy_to_user(arg, &sr, sizeof(sr))) 1871 + return -EFAULT; 1872 + return 0; 1873 + } 1874 + read_unlock(&mrt_lock); 1875 + return -EADDRNOTAVAIL; 1876 + default: 1877 + return -ENOIOCTLCMD; 1878 + } 1879 + } 1880 + #endif 1808 1881 1809 1882 static inline int ip6mr_forward2_finish(struct sk_buff *skb) 1810 1883 {
+19
net/ipv6/raw.c
··· 31 31 #include <linux/netfilter.h> 32 32 #include <linux/netfilter_ipv6.h> 33 33 #include <linux/skbuff.h> 34 + #include <linux/compat.h> 34 35 #include <asm/uaccess.h> 35 36 #include <asm/ioctls.h> 36 37 ··· 1158 1157 } 1159 1158 } 1160 1159 1160 + #ifdef CONFIG_COMPAT 1161 + static int compat_rawv6_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg) 1162 + { 1163 + switch (cmd) { 1164 + case SIOCOUTQ: 1165 + case SIOCINQ: 1166 + return -ENOIOCTLCMD; 1167 + default: 1168 + #ifdef CONFIG_IPV6_MROUTE 1169 + return ip6mr_compat_ioctl(sk, cmd, compat_ptr(arg)); 1170 + #else 1171 + return -ENOIOCTLCMD; 1172 + #endif 1173 + } 1174 + } 1175 + #endif 1176 + 1161 1177 static void rawv6_close(struct sock *sk, long timeout) 1162 1178 { 1163 1179 if (inet_sk(sk)->inet_num == IPPROTO_RAW) ··· 1233 1215 #ifdef CONFIG_COMPAT 1234 1216 .compat_setsockopt = compat_rawv6_setsockopt, 1235 1217 .compat_getsockopt = compat_rawv6_getsockopt, 1218 + .compat_ioctl = compat_rawv6_ioctl, 1236 1219 #endif 1237 1220 }; 1238 1221
+6 -4
net/ipv6/route.c
··· 113 113 .local_out = __ip6_local_out, 114 114 }; 115 115 116 + static unsigned int ip6_blackhole_default_mtu(const struct dst_entry *dst) 117 + { 118 + return 0; 119 + } 120 + 116 121 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu) 117 122 { 118 123 } ··· 127 122 .protocol = cpu_to_be16(ETH_P_IPV6), 128 123 .destroy = ip6_dst_destroy, 129 124 .check = ip6_dst_check, 125 + .default_mtu = ip6_blackhole_default_mtu, 130 126 .update_pmtu = ip6_rt_blackhole_update_pmtu, 131 127 }; 132 128 ··· 200 194 in6_dev_put(idev); 201 195 } 202 196 if (peer) { 203 - BUG_ON(!(rt->rt6i_flags & RTF_CACHE)); 204 197 rt->rt6i_peer = NULL; 205 198 inet_putpeer(peer); 206 199 } ··· 208 203 void rt6_bind_peer(struct rt6_info *rt, int create) 209 204 { 210 205 struct inet_peer *peer; 211 - 212 - if (WARN_ON(!(rt->rt6i_flags & RTF_CACHE))) 213 - return; 214 206 215 207 peer = inet_getpeer_v6(&rt->rt6i_dst.addr, create); 216 208 if (peer && cmpxchg(&rt->rt6i_peer, NULL, peer) != NULL)
+8 -1
net/ipv6/sysctl_net_ipv6.c
··· 15 15 #include <net/addrconf.h> 16 16 #include <net/inet_frag.h> 17 17 18 + static struct ctl_table empty[1]; 19 + 18 20 static ctl_table ipv6_table_template[] = { 19 21 { 20 22 .procname = "route", ··· 36 34 .maxlen = sizeof(int), 37 35 .mode = 0644, 38 36 .proc_handler = proc_dointvec 37 + }, 38 + { 39 + .procname = "neigh", 40 + .maxlen = 0, 41 + .mode = 0555, 42 + .child = empty, 39 43 }, 40 44 { } 41 45 }; ··· 160 152 161 153 int ipv6_static_sysctl_register(void) 162 154 { 163 - static struct ctl_table empty[1]; 164 155 ip6_base = register_sysctl_paths(net_ipv6_ctl_path, empty); 165 156 if (ip6_base == NULL) 166 157 return -ENOMEM;
+3
net/netfilter/nf_conntrack_ecache.c
··· 63 63 * this does not harm and it happens very rarely. */ 64 64 unsigned long missed = e->missed; 65 65 66 + if (!((events | missed) & e->ctmask)) 67 + goto out_unlock; 68 + 66 69 ret = notify->fcn(events | missed, &item); 67 70 if (unlikely(ret < 0 || missed)) { 68 71 spin_lock_bh(&ct->lock);
+1
net/netfilter/nf_conntrack_netlink.c
··· 667 667 if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid, 668 668 cb->nlh->nlmsg_seq, 669 669 IPCTNL_MSG_CT_NEW, ct) < 0) { 670 + nf_conntrack_get(&ct->ct_general); 670 671 cb->args[1] = (unsigned long)ct; 671 672 goto out; 672 673 }
+7 -9
net/netfilter/xt_iprange.c
··· 53 53 } 54 54 55 55 static inline int 56 - iprange_ipv6_sub(const struct in6_addr *a, const struct in6_addr *b) 56 + iprange_ipv6_lt(const struct in6_addr *a, const struct in6_addr *b) 57 57 { 58 58 unsigned int i; 59 - int r; 60 59 61 60 for (i = 0; i < 4; ++i) { 62 - r = ntohl(a->s6_addr32[i]) - ntohl(b->s6_addr32[i]); 63 - if (r != 0) 64 - return r; 61 + if (a->s6_addr32[i] != b->s6_addr32[i]) 62 + return ntohl(a->s6_addr32[i]) < ntohl(b->s6_addr32[i]); 65 63 } 66 64 67 65 return 0; ··· 73 75 bool m; 74 76 75 77 if (info->flags & IPRANGE_SRC) { 76 - m = iprange_ipv6_sub(&iph->saddr, &info->src_min.in6) < 0; 77 - m |= iprange_ipv6_sub(&iph->saddr, &info->src_max.in6) > 0; 78 + m = iprange_ipv6_lt(&iph->saddr, &info->src_min.in6); 79 + m |= iprange_ipv6_lt(&info->src_max.in6, &iph->saddr); 78 80 m ^= !!(info->flags & IPRANGE_SRC_INV); 79 81 if (m) 80 82 return false; 81 83 } 82 84 if (info->flags & IPRANGE_DST) { 83 - m = iprange_ipv6_sub(&iph->daddr, &info->dst_min.in6) < 0; 84 - m |= iprange_ipv6_sub(&iph->daddr, &info->dst_max.in6) > 0; 85 + m = iprange_ipv6_lt(&iph->daddr, &info->dst_min.in6); 86 + m |= iprange_ipv6_lt(&info->dst_max.in6, &iph->daddr); 85 87 m ^= !!(info->flags & IPRANGE_DST_INV); 86 88 if (m) 87 89 return false;