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:
"Some straggler bug fixes here:

1) Netlink_sendmsg() doesn't check iterator type properly in mmap
case, from Ken-ichirou MATSUZAWA.

2) Don't sleep in atomic context in bcmgenet driver, from Florian
Fainelli.

3) The pfkey_broadcast() code patch can't actually ever use anything
other than GFP_ATOMIC. And the cases that right now pass
GFP_KERNEL or similar will currently trigger an RCU splat. Just
use GFP_ATOMIC unconditionally. From David Ahern.

4) Fix FD bit timings handling in pcan_usb driver, from Marc
Kleine-Budde.

5) Cache dst leaked in ip6_gre tunnel removal, fix from Huaibin Wang.

6) Traversal into drivers/net/ethernet/renesas should be triggered by
CONFIG_NET_VENDOR_RENESAS, not a particular driver's config
option. From Kazuya Mizuguchi.

7) Fix regression in handling of igmp_join errors in vxlan, from
Marcelo Ricardo Leitner.

8) Make phy_{read,write}_mmd_indirect() properly take the mdio_lock
mutex when programming the registers. From Russell King.

9) Fix non-forced handling in u32_destroy(), from WANG Cong.

10) Test the EVENT_NO_RUNTIME_PM flag before it is cleared in
usbnet_stop(), from Eugene Shatokhin.

11) In sfc driver, don't fetch statistics firmware isn't capable of,
from Bert Kenward.

12) Verify ASCONF address parameter location in SCTP, from Xin Long"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net:
sctp: donot reset the overall_error_count in SHUTDOWN_RECEIVE state
sctp: asconf's process should verify address parameter is in the beginning
sfc: only use vadaptor stats if firmware is capable
net: phy: fixed: propagate fixed link values to struct
usbnet: Get EVENT_NO_RUNTIME_PM bit before it is cleared
drivers: net: xgene: fix: Oops in linkwatch_fire_event
cls_u32: complete the check for non-forced case in u32_destroy()
net: fec: use reinit_completion() in mdio accessor functions
net: phy: add locking to phy_read_mmd_indirect()/phy_write_mmd_indirect()
vxlan: re-ignore EADDRINUSE from igmp_join
net: compile renesas directory if NET_VENDOR_RENESAS is configured
ip6_gre: release cached dst on tunnel removal
phylib: Make PHYs children of their MDIO bus, not the bus' parent.
can: pcan_usb: don't provide CAN FD bittimings by non-FD adapters
net: Fix RCU splat in af_key
net: bcmgenet: fix uncleaned dma flags
net: bcmgenet: Avoid sleeping in bcmgenet_timeout
netlink: mmap: fix tx type check

+207 -113
+13 -11
drivers/net/can/usb/peak_usb/pcan_usb.c
··· 854 854 /* 855 855 * describe the PCAN-USB adapter 856 856 */ 857 + static const struct can_bittiming_const pcan_usb_const = { 858 + .name = "pcan_usb", 859 + .tseg1_min = 1, 860 + .tseg1_max = 16, 861 + .tseg2_min = 1, 862 + .tseg2_max = 8, 863 + .sjw_max = 4, 864 + .brp_min = 1, 865 + .brp_max = 64, 866 + .brp_inc = 1, 867 + }; 868 + 857 869 const struct peak_usb_adapter pcan_usb = { 858 870 .name = "PCAN-USB", 859 871 .device_id = PCAN_USB_PRODUCT_ID, ··· 874 862 .clock = { 875 863 .freq = PCAN_USB_CRYSTAL_HZ / 2 , 876 864 }, 877 - .bittiming_const = { 878 - .name = "pcan_usb", 879 - .tseg1_min = 1, 880 - .tseg1_max = 16, 881 - .tseg2_min = 1, 882 - .tseg2_max = 8, 883 - .sjw_max = 4, 884 - .brp_min = 1, 885 - .brp_max = 64, 886 - .brp_inc = 1, 887 - }, 865 + .bittiming_const = &pcan_usb_const, 888 866 889 867 /* size of device private data */ 890 868 .sizeof_dev_private = sizeof(struct pcan_usb),
+2 -2
drivers/net/can/usb/peak_usb/pcan_usb_core.c
··· 792 792 dev->ep_msg_out = peak_usb_adapter->ep_msg_out[ctrl_idx]; 793 793 794 794 dev->can.clock = peak_usb_adapter->clock; 795 - dev->can.bittiming_const = &peak_usb_adapter->bittiming_const; 795 + dev->can.bittiming_const = peak_usb_adapter->bittiming_const; 796 796 dev->can.do_set_bittiming = peak_usb_set_bittiming; 797 - dev->can.data_bittiming_const = &peak_usb_adapter->data_bittiming_const; 797 + dev->can.data_bittiming_const = peak_usb_adapter->data_bittiming_const; 798 798 dev->can.do_set_data_bittiming = peak_usb_set_data_bittiming; 799 799 dev->can.do_set_mode = peak_usb_set_mode; 800 800 dev->can.do_get_berr_counter = peak_usb_adapter->do_get_berr_counter;
+2 -2
drivers/net/can/usb/peak_usb/pcan_usb_core.h
··· 48 48 u32 device_id; 49 49 u32 ctrlmode_supported; 50 50 struct can_clock clock; 51 - const struct can_bittiming_const bittiming_const; 52 - const struct can_bittiming_const data_bittiming_const; 51 + const struct can_bittiming_const * const bittiming_const; 52 + const struct can_bittiming_const * const data_bittiming_const; 53 53 unsigned int ctrl_count; 54 54 55 55 int (*intf_probe)(struct usb_interface *intf);
+52 -44
drivers/net/can/usb/peak_usb/pcan_usb_fd.c
··· 990 990 } 991 991 992 992 /* describes the PCAN-USB FD adapter */ 993 + static const struct can_bittiming_const pcan_usb_fd_const = { 994 + .name = "pcan_usb_fd", 995 + .tseg1_min = 1, 996 + .tseg1_max = 64, 997 + .tseg2_min = 1, 998 + .tseg2_max = 16, 999 + .sjw_max = 16, 1000 + .brp_min = 1, 1001 + .brp_max = 1024, 1002 + .brp_inc = 1, 1003 + }; 1004 + 1005 + static const struct can_bittiming_const pcan_usb_fd_data_const = { 1006 + .name = "pcan_usb_fd", 1007 + .tseg1_min = 1, 1008 + .tseg1_max = 16, 1009 + .tseg2_min = 1, 1010 + .tseg2_max = 8, 1011 + .sjw_max = 4, 1012 + .brp_min = 1, 1013 + .brp_max = 1024, 1014 + .brp_inc = 1, 1015 + }; 1016 + 993 1017 const struct peak_usb_adapter pcan_usb_fd = { 994 1018 .name = "PCAN-USB FD", 995 1019 .device_id = PCAN_USBFD_PRODUCT_ID, ··· 1023 999 .clock = { 1024 1000 .freq = PCAN_UFD_CRYSTAL_HZ, 1025 1001 }, 1026 - .bittiming_const = { 1027 - .name = "pcan_usb_fd", 1028 - .tseg1_min = 1, 1029 - .tseg1_max = 64, 1030 - .tseg2_min = 1, 1031 - .tseg2_max = 16, 1032 - .sjw_max = 16, 1033 - .brp_min = 1, 1034 - .brp_max = 1024, 1035 - .brp_inc = 1, 1036 - }, 1037 - .data_bittiming_const = { 1038 - .name = "pcan_usb_fd", 1039 - .tseg1_min = 1, 1040 - .tseg1_max = 16, 1041 - .tseg2_min = 1, 1042 - .tseg2_max = 8, 1043 - .sjw_max = 4, 1044 - .brp_min = 1, 1045 - .brp_max = 1024, 1046 - .brp_inc = 1, 1047 - }, 1002 + .bittiming_const = &pcan_usb_fd_const, 1003 + .data_bittiming_const = &pcan_usb_fd_data_const, 1048 1004 1049 1005 /* size of device private data */ 1050 1006 .sizeof_dev_private = sizeof(struct pcan_usb_fd_device), ··· 1062 1058 }; 1063 1059 1064 1060 /* describes the PCAN-USB Pro FD adapter */ 1061 + static const struct can_bittiming_const pcan_usb_pro_fd_const = { 1062 + .name = "pcan_usb_pro_fd", 1063 + .tseg1_min = 1, 1064 + .tseg1_max = 64, 1065 + .tseg2_min = 1, 1066 + .tseg2_max = 16, 1067 + .sjw_max = 16, 1068 + .brp_min = 1, 1069 + .brp_max = 1024, 1070 + .brp_inc = 1, 1071 + }; 1072 + 1073 + static const struct can_bittiming_const pcan_usb_pro_fd_data_const = { 1074 + .name = "pcan_usb_pro_fd", 1075 + .tseg1_min = 1, 1076 + .tseg1_max = 16, 1077 + .tseg2_min = 1, 1078 + .tseg2_max = 8, 1079 + .sjw_max = 4, 1080 + .brp_min = 1, 1081 + .brp_max = 1024, 1082 + .brp_inc = 1, 1083 + }; 1084 + 1065 1085 const struct peak_usb_adapter pcan_usb_pro_fd = { 1066 1086 .name = "PCAN-USB Pro FD", 1067 1087 .device_id = PCAN_USBPROFD_PRODUCT_ID, ··· 1095 1067 .clock = { 1096 1068 .freq = PCAN_UFD_CRYSTAL_HZ, 1097 1069 }, 1098 - .bittiming_const = { 1099 - .name = "pcan_usb_pro_fd", 1100 - .tseg1_min = 1, 1101 - .tseg1_max = 64, 1102 - .tseg2_min = 1, 1103 - .tseg2_max = 16, 1104 - .sjw_max = 16, 1105 - .brp_min = 1, 1106 - .brp_max = 1024, 1107 - .brp_inc = 1, 1108 - }, 1109 - .data_bittiming_const = { 1110 - .name = "pcan_usb_pro_fd", 1111 - .tseg1_min = 1, 1112 - .tseg1_max = 16, 1113 - .tseg2_min = 1, 1114 - .tseg2_max = 8, 1115 - .sjw_max = 4, 1116 - .brp_min = 1, 1117 - .brp_max = 1024, 1118 - .brp_inc = 1, 1119 - }, 1070 + .bittiming_const = &pcan_usb_pro_fd_const, 1071 + .data_bittiming_const = &pcan_usb_pro_fd_data_const, 1120 1072 1121 1073 /* size of device private data */ 1122 1074 .sizeof_dev_private = sizeof(struct pcan_usb_fd_device),
+13 -11
drivers/net/can/usb/peak_usb/pcan_usb_pro.c
··· 1004 1004 /* 1005 1005 * describe the PCAN-USB Pro adapter 1006 1006 */ 1007 + static const struct can_bittiming_const pcan_usb_pro_const = { 1008 + .name = "pcan_usb_pro", 1009 + .tseg1_min = 1, 1010 + .tseg1_max = 16, 1011 + .tseg2_min = 1, 1012 + .tseg2_max = 8, 1013 + .sjw_max = 4, 1014 + .brp_min = 1, 1015 + .brp_max = 1024, 1016 + .brp_inc = 1, 1017 + }; 1018 + 1007 1019 const struct peak_usb_adapter pcan_usb_pro = { 1008 1020 .name = "PCAN-USB Pro", 1009 1021 .device_id = PCAN_USBPRO_PRODUCT_ID, ··· 1024 1012 .clock = { 1025 1013 .freq = PCAN_USBPRO_CRYSTAL_HZ, 1026 1014 }, 1027 - .bittiming_const = { 1028 - .name = "pcan_usb_pro", 1029 - .tseg1_min = 1, 1030 - .tseg1_max = 16, 1031 - .tseg2_min = 1, 1032 - .tseg2_max = 8, 1033 - .sjw_max = 4, 1034 - .brp_min = 1, 1035 - .brp_max = 1024, 1036 - .brp_inc = 1, 1037 - }, 1015 + .bittiming_const = &pcan_usb_pro_const, 1038 1016 1039 1017 /* size of device private data */ 1040 1018 .sizeof_dev_private = sizeof(struct pcan_usb_pro_device),
+1 -1
drivers/net/ethernet/Makefile
··· 65 65 obj-$(CONFIG_NET_VENDOR_QLOGIC) += qlogic/ 66 66 obj-$(CONFIG_NET_VENDOR_QUALCOMM) += qualcomm/ 67 67 obj-$(CONFIG_NET_VENDOR_REALTEK) += realtek/ 68 - obj-$(CONFIG_SH_ETH) += renesas/ 68 + obj-$(CONFIG_NET_VENDOR_RENESAS) += renesas/ 69 69 obj-$(CONFIG_NET_VENDOR_RDC) += rdc/ 70 70 obj-$(CONFIG_NET_VENDOR_ROCKER) += rocker/ 71 71 obj-$(CONFIG_NET_VENDOR_SAMSUNG) += samsung/
+3
drivers/net/ethernet/apm/xgene/xgene_enet_hw.c
··· 801 801 802 802 void xgene_enet_mdio_remove(struct xgene_enet_pdata *pdata) 803 803 { 804 + if (pdata->phy_dev) 805 + phy_disconnect(pdata->phy_dev); 806 + 804 807 mdiobus_unregister(pdata->mdio_bus); 805 808 mdiobus_free(pdata->mdio_bus); 806 809 pdata->mdio_bus = NULL;
+3 -2
drivers/net/ethernet/apm/xgene/xgene_enet_main.c
··· 1277 1277 mac_ops->tx_disable(pdata); 1278 1278 1279 1279 xgene_enet_napi_del(pdata); 1280 - xgene_enet_mdio_remove(pdata); 1281 - xgene_enet_delete_desc_rings(pdata); 1280 + if (pdata->phy_mode == PHY_INTERFACE_MODE_RGMII) 1281 + xgene_enet_mdio_remove(pdata); 1282 1282 unregister_netdev(ndev); 1283 + xgene_enet_delete_desc_rings(pdata); 1283 1284 pdata->port_ops->shutdown(pdata); 1284 1285 free_netdev(ndev); 1285 1286
+16 -4
drivers/net/ethernet/broadcom/genet/bcmgenet.c
··· 2126 2126 int ret = 0; 2127 2127 int timeout = 0; 2128 2128 u32 reg; 2129 + u32 dma_ctrl; 2130 + int i; 2129 2131 2130 2132 /* Disable TDMA to stop add more frames in TX DMA */ 2131 2133 reg = bcmgenet_tdma_readl(priv, DMA_CTRL); ··· 2170 2168 netdev_warn(priv->dev, "Timed out while disabling RX DMA\n"); 2171 2169 ret = -ETIMEDOUT; 2172 2170 } 2171 + 2172 + dma_ctrl = 0; 2173 + for (i = 0; i < priv->hw_params->rx_queues; i++) 2174 + dma_ctrl |= (1 << (i + DMA_RING_BUF_EN_SHIFT)); 2175 + reg = bcmgenet_rdma_readl(priv, DMA_CTRL); 2176 + reg &= ~dma_ctrl; 2177 + bcmgenet_rdma_writel(priv, reg, DMA_CTRL); 2178 + 2179 + dma_ctrl = 0; 2180 + for (i = 0; i < priv->hw_params->tx_queues; i++) 2181 + dma_ctrl |= (1 << (i + DMA_RING_BUF_EN_SHIFT)); 2182 + reg = bcmgenet_tdma_readl(priv, DMA_CTRL); 2183 + reg &= ~dma_ctrl; 2184 + bcmgenet_tdma_writel(priv, reg, DMA_CTRL); 2173 2185 2174 2186 return ret; 2175 2187 } ··· 2836 2820 2837 2821 netif_dbg(priv, tx_err, dev, "bcmgenet_timeout\n"); 2838 2822 2839 - bcmgenet_disable_tx_napi(priv); 2840 - 2841 2823 for (q = 0; q < priv->hw_params->tx_queues; q++) 2842 2824 bcmgenet_dump_tx_queue(&priv->tx_rings[q]); 2843 2825 bcmgenet_dump_tx_queue(&priv->tx_rings[DESC_INDEX]); ··· 2850 2836 /* Re-enable TX interrupts if disabled */ 2851 2837 bcmgenet_intrl2_0_writel(priv, int0_enable, INTRL2_CPU_MASK_CLEAR); 2852 2838 bcmgenet_intrl2_1_writel(priv, int1_enable, INTRL2_CPU_MASK_CLEAR); 2853 - 2854 - bcmgenet_enable_tx_napi(priv); 2855 2839 2856 2840 dev->trans_start = jiffies; 2857 2841
+2 -2
drivers/net/ethernet/freescale/fec_main.c
··· 1778 1778 return ret; 1779 1779 1780 1780 fep->mii_timeout = 0; 1781 - init_completion(&fep->mdio_done); 1781 + reinit_completion(&fep->mdio_done); 1782 1782 1783 1783 /* start a read op */ 1784 1784 writel(FEC_MMFR_ST | FEC_MMFR_OP_READ | ··· 1817 1817 return ret; 1818 1818 1819 1819 fep->mii_timeout = 0; 1820 - init_completion(&fep->mdio_done); 1820 + reinit_completion(&fep->mdio_done); 1821 1821 1822 1822 /* start a write op */ 1823 1823 writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
+26 -1
drivers/net/ethernet/sfc/ef10.c
··· 1282 1282 } 1283 1283 } 1284 1284 1285 - if (core_stats) { 1285 + if (!core_stats) 1286 + return stats_count; 1287 + 1288 + if (nic_data->datapath_caps & 1289 + 1 << MC_CMD_GET_CAPABILITIES_OUT_EVB_LBN) { 1290 + /* Use vadaptor stats. */ 1286 1291 core_stats->rx_packets = stats[EF10_STAT_rx_unicast] + 1287 1292 stats[EF10_STAT_rx_multicast] + 1288 1293 stats[EF10_STAT_rx_broadcast]; ··· 1307 1302 core_stats->rx_fifo_errors = stats[EF10_STAT_rx_overflow]; 1308 1303 core_stats->rx_errors = core_stats->rx_crc_errors; 1309 1304 core_stats->tx_errors = stats[EF10_STAT_tx_bad]; 1305 + } else { 1306 + /* Use port stats. */ 1307 + core_stats->rx_packets = stats[EF10_STAT_port_rx_packets]; 1308 + core_stats->tx_packets = stats[EF10_STAT_port_tx_packets]; 1309 + core_stats->rx_bytes = stats[EF10_STAT_port_rx_bytes]; 1310 + core_stats->tx_bytes = stats[EF10_STAT_port_tx_bytes]; 1311 + core_stats->rx_dropped = stats[EF10_STAT_port_rx_nodesc_drops] + 1312 + stats[GENERIC_STAT_rx_nodesc_trunc] + 1313 + stats[GENERIC_STAT_rx_noskb_drops]; 1314 + core_stats->multicast = stats[EF10_STAT_port_rx_multicast]; 1315 + core_stats->rx_length_errors = 1316 + stats[EF10_STAT_port_rx_gtjumbo] + 1317 + stats[EF10_STAT_port_rx_length_error]; 1318 + core_stats->rx_crc_errors = stats[EF10_STAT_port_rx_bad]; 1319 + core_stats->rx_frame_errors = 1320 + stats[EF10_STAT_port_rx_align_error]; 1321 + core_stats->rx_fifo_errors = stats[EF10_STAT_port_rx_overflow]; 1322 + core_stats->rx_errors = (core_stats->rx_length_errors + 1323 + core_stats->rx_crc_errors + 1324 + core_stats->rx_frame_errors); 1310 1325 } 1311 1326 1312 1327 return stats_count;
+9
drivers/net/phy/fixed_phy.c
··· 290 290 return ERR_PTR(-EINVAL); 291 291 } 292 292 293 + /* propagate the fixed link values to struct phy_device */ 294 + phy->link = status->link; 295 + if (status->link) { 296 + phy->speed = status->speed; 297 + phy->duplex = status->duplex; 298 + phy->pause = status->pause; 299 + phy->asym_pause = status->asym_pause; 300 + } 301 + 293 302 of_node_get(np); 294 303 phy->dev.of_node = np; 295 304
+12 -4
drivers/net/phy/phy.c
··· 1038 1038 int value = -1; 1039 1039 1040 1040 if (phydrv->read_mmd_indirect == NULL) { 1041 - mmd_phy_indirect(phydev->bus, prtad, devad, addr); 1041 + struct mii_bus *bus = phydev->bus; 1042 + 1043 + mutex_lock(&bus->mdio_lock); 1044 + mmd_phy_indirect(bus, prtad, devad, addr); 1042 1045 1043 1046 /* Read the content of the MMD's selected register */ 1044 - value = phydev->bus->read(phydev->bus, addr, MII_MMD_DATA); 1047 + value = bus->read(bus, addr, MII_MMD_DATA); 1048 + mutex_unlock(&bus->mdio_lock); 1045 1049 } else { 1046 1050 value = phydrv->read_mmd_indirect(phydev, prtad, devad, addr); 1047 1051 } ··· 1075 1071 struct phy_driver *phydrv = phydev->drv; 1076 1072 1077 1073 if (phydrv->write_mmd_indirect == NULL) { 1078 - mmd_phy_indirect(phydev->bus, prtad, devad, addr); 1074 + struct mii_bus *bus = phydev->bus; 1075 + 1076 + mutex_lock(&bus->mdio_lock); 1077 + mmd_phy_indirect(bus, prtad, devad, addr); 1079 1078 1080 1079 /* Write the data into MMD's selected register */ 1081 - phydev->bus->write(phydev->bus, addr, MII_MMD_DATA, data); 1080 + bus->write(bus, addr, MII_MMD_DATA, data); 1081 + mutex_unlock(&bus->mdio_lock); 1082 1082 } else { 1083 1083 phydrv->write_mmd_indirect(phydev, prtad, devad, addr, data); 1084 1084 }
+1 -1
drivers/net/phy/phy_device.c
··· 176 176 if (c45_ids) 177 177 dev->c45_ids = *c45_ids; 178 178 dev->bus = bus; 179 - dev->dev.parent = bus->parent; 179 + dev->dev.parent = &bus->dev; 180 180 dev->dev.bus = &mdio_bus_type; 181 181 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL; 182 182 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
+4 -3
drivers/net/usb/usbnet.c
··· 778 778 { 779 779 struct usbnet *dev = netdev_priv(net); 780 780 struct driver_info *info = dev->driver_info; 781 - int retval, pm; 781 + int retval, pm, mpn; 782 782 783 783 clear_bit(EVENT_DEV_OPEN, &dev->flags); 784 784 netif_stop_queue (net); ··· 809 809 810 810 usbnet_purge_paused_rxq(dev); 811 811 812 + mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags); 813 + 812 814 /* deferred work (task, timer, softirq) must also stop. 813 815 * can't flush_scheduled_work() until we drop rtnl (later), 814 816 * else workers could deadlock; so make workers a NOP. ··· 821 819 if (!pm) 822 820 usb_autopm_put_interface(dev->intf); 823 821 824 - if (info->manage_power && 825 - !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags)) 822 + if (info->manage_power && mpn) 826 823 info->manage_power(dev, 0); 827 824 else 828 825 usb_autopm_put_interface(dev->intf);
+2
drivers/net/vxlan.c
··· 2216 2216 2217 2217 if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) { 2218 2218 ret = vxlan_igmp_join(vxlan); 2219 + if (ret == -EADDRINUSE) 2220 + ret = 0; 2219 2221 if (ret) { 2220 2222 vxlan_sock_release(vs); 2221 2223 return ret;
+1
net/ipv6/ip6_gre.c
··· 361 361 struct ip6gre_net *ign = net_generic(t->net, ip6gre_net_id); 362 362 363 363 ip6gre_tunnel_unlink(ign, t); 364 + ip6_tnl_dst_reset(t); 364 365 dev_put(dev); 365 366 } 366 367
+23 -23
net/key/af_key.c
··· 219 219 #define BROADCAST_ONE 1 220 220 #define BROADCAST_REGISTERED 2 221 221 #define BROADCAST_PROMISC_ONLY 4 222 - static int pfkey_broadcast(struct sk_buff *skb, gfp_t allocation, 222 + static int pfkey_broadcast(struct sk_buff *skb, 223 223 int broadcast_flags, struct sock *one_sk, 224 224 struct net *net) 225 225 { ··· 244 244 * socket. 245 245 */ 246 246 if (pfk->promisc) 247 - pfkey_broadcast_one(skb, &skb2, allocation, sk); 247 + pfkey_broadcast_one(skb, &skb2, GFP_ATOMIC, sk); 248 248 249 249 /* the exact target will be processed later */ 250 250 if (sk == one_sk) ··· 259 259 continue; 260 260 } 261 261 262 - err2 = pfkey_broadcast_one(skb, &skb2, allocation, sk); 262 + err2 = pfkey_broadcast_one(skb, &skb2, GFP_ATOMIC, sk); 263 263 264 264 /* Error is cleare after succecful sending to at least one 265 265 * registered KM */ ··· 269 269 rcu_read_unlock(); 270 270 271 271 if (one_sk != NULL) 272 - err = pfkey_broadcast_one(skb, &skb2, allocation, one_sk); 272 + err = pfkey_broadcast_one(skb, &skb2, GFP_KERNEL, one_sk); 273 273 274 274 kfree_skb(skb2); 275 275 kfree_skb(skb); ··· 292 292 hdr = (struct sadb_msg *) pfk->dump.skb->data; 293 293 hdr->sadb_msg_seq = 0; 294 294 hdr->sadb_msg_errno = rc; 295 - pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE, 295 + pfkey_broadcast(pfk->dump.skb, BROADCAST_ONE, 296 296 &pfk->sk, sock_net(&pfk->sk)); 297 297 pfk->dump.skb = NULL; 298 298 } ··· 333 333 hdr->sadb_msg_len = (sizeof(struct sadb_msg) / 334 334 sizeof(uint64_t)); 335 335 336 - pfkey_broadcast(skb, GFP_KERNEL, BROADCAST_ONE, sk, sock_net(sk)); 336 + pfkey_broadcast(skb, BROADCAST_ONE, sk, sock_net(sk)); 337 337 338 338 return 0; 339 339 } ··· 1365 1365 1366 1366 xfrm_state_put(x); 1367 1367 1368 - pfkey_broadcast(resp_skb, GFP_KERNEL, BROADCAST_ONE, sk, net); 1368 + pfkey_broadcast(resp_skb, BROADCAST_ONE, sk, net); 1369 1369 1370 1370 return 0; 1371 1371 } ··· 1452 1452 hdr->sadb_msg_seq = c->seq; 1453 1453 hdr->sadb_msg_pid = c->portid; 1454 1454 1455 - pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ALL, NULL, xs_net(x)); 1455 + pfkey_broadcast(skb, BROADCAST_ALL, NULL, xs_net(x)); 1456 1456 1457 1457 return 0; 1458 1458 } ··· 1565 1565 out_hdr->sadb_msg_reserved = 0; 1566 1566 out_hdr->sadb_msg_seq = hdr->sadb_msg_seq; 1567 1567 out_hdr->sadb_msg_pid = hdr->sadb_msg_pid; 1568 - pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, sk, sock_net(sk)); 1568 + pfkey_broadcast(out_skb, BROADCAST_ONE, sk, sock_net(sk)); 1569 1569 1570 1570 return 0; 1571 1571 } ··· 1670 1670 return -ENOBUFS; 1671 1671 } 1672 1672 1673 - pfkey_broadcast(supp_skb, GFP_KERNEL, BROADCAST_REGISTERED, sk, sock_net(sk)); 1673 + pfkey_broadcast(supp_skb, BROADCAST_REGISTERED, sk, sock_net(sk)); 1674 1674 1675 1675 return 0; 1676 1676 } ··· 1689 1689 hdr->sadb_msg_errno = (uint8_t) 0; 1690 1690 hdr->sadb_msg_len = (sizeof(struct sadb_msg) / sizeof(uint64_t)); 1691 1691 1692 - return pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ONE, sk, sock_net(sk)); 1692 + return pfkey_broadcast(skb, BROADCAST_ONE, sk, sock_net(sk)); 1693 1693 } 1694 1694 1695 1695 static int key_notify_sa_flush(const struct km_event *c) ··· 1710 1710 hdr->sadb_msg_len = (sizeof(struct sadb_msg) / sizeof(uint64_t)); 1711 1711 hdr->sadb_msg_reserved = 0; 1712 1712 1713 - pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ALL, NULL, c->net); 1713 + pfkey_broadcast(skb, BROADCAST_ALL, NULL, c->net); 1714 1714 1715 1715 return 0; 1716 1716 } ··· 1767 1767 out_hdr->sadb_msg_pid = pfk->dump.msg_portid; 1768 1768 1769 1769 if (pfk->dump.skb) 1770 - pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE, 1770 + pfkey_broadcast(pfk->dump.skb, BROADCAST_ONE, 1771 1771 &pfk->sk, sock_net(&pfk->sk)); 1772 1772 pfk->dump.skb = out_skb; 1773 1773 ··· 1847 1847 new_hdr->sadb_msg_errno = 0; 1848 1848 } 1849 1849 1850 - pfkey_broadcast(skb, GFP_KERNEL, BROADCAST_ALL, NULL, sock_net(sk)); 1850 + pfkey_broadcast(skb, BROADCAST_ALL, NULL, sock_net(sk)); 1851 1851 return 0; 1852 1852 } 1853 1853 ··· 2181 2181 out_hdr->sadb_msg_errno = 0; 2182 2182 out_hdr->sadb_msg_seq = c->seq; 2183 2183 out_hdr->sadb_msg_pid = c->portid; 2184 - pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ALL, NULL, xp_net(xp)); 2184 + pfkey_broadcast(out_skb, BROADCAST_ALL, NULL, xp_net(xp)); 2185 2185 return 0; 2186 2186 2187 2187 } ··· 2401 2401 out_hdr->sadb_msg_errno = 0; 2402 2402 out_hdr->sadb_msg_seq = hdr->sadb_msg_seq; 2403 2403 out_hdr->sadb_msg_pid = hdr->sadb_msg_pid; 2404 - pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, sk, xp_net(xp)); 2404 + pfkey_broadcast(out_skb, BROADCAST_ONE, sk, xp_net(xp)); 2405 2405 err = 0; 2406 2406 2407 2407 out: ··· 2655 2655 out_hdr->sadb_msg_pid = pfk->dump.msg_portid; 2656 2656 2657 2657 if (pfk->dump.skb) 2658 - pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE, 2658 + pfkey_broadcast(pfk->dump.skb, BROADCAST_ONE, 2659 2659 &pfk->sk, sock_net(&pfk->sk)); 2660 2660 pfk->dump.skb = out_skb; 2661 2661 ··· 2708 2708 hdr->sadb_msg_satype = SADB_SATYPE_UNSPEC; 2709 2709 hdr->sadb_msg_len = (sizeof(struct sadb_msg) / sizeof(uint64_t)); 2710 2710 hdr->sadb_msg_reserved = 0; 2711 - pfkey_broadcast(skb_out, GFP_ATOMIC, BROADCAST_ALL, NULL, c->net); 2711 + pfkey_broadcast(skb_out, BROADCAST_ALL, NULL, c->net); 2712 2712 return 0; 2713 2713 2714 2714 } ··· 2770 2770 void *ext_hdrs[SADB_EXT_MAX]; 2771 2771 int err; 2772 2772 2773 - pfkey_broadcast(skb_clone(skb, GFP_KERNEL), GFP_KERNEL, 2773 + pfkey_broadcast(skb_clone(skb, GFP_KERNEL), 2774 2774 BROADCAST_PROMISC_ONLY, NULL, sock_net(sk)); 2775 2775 2776 2776 memset(ext_hdrs, 0, sizeof(ext_hdrs)); ··· 2992 2992 out_hdr->sadb_msg_seq = 0; 2993 2993 out_hdr->sadb_msg_pid = 0; 2994 2994 2995 - pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_REGISTERED, NULL, xs_net(x)); 2995 + pfkey_broadcast(out_skb, BROADCAST_REGISTERED, NULL, xs_net(x)); 2996 2996 return 0; 2997 2997 } 2998 2998 ··· 3182 3182 xfrm_ctx->ctx_len); 3183 3183 } 3184 3184 3185 - return pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_REGISTERED, NULL, xs_net(x)); 3185 + return pfkey_broadcast(skb, BROADCAST_REGISTERED, NULL, xs_net(x)); 3186 3186 } 3187 3187 3188 3188 static struct xfrm_policy *pfkey_compile_policy(struct sock *sk, int opt, ··· 3380 3380 n_port->sadb_x_nat_t_port_port = sport; 3381 3381 n_port->sadb_x_nat_t_port_reserved = 0; 3382 3382 3383 - return pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_REGISTERED, NULL, xs_net(x)); 3383 + return pfkey_broadcast(skb, BROADCAST_REGISTERED, NULL, xs_net(x)); 3384 3384 } 3385 3385 3386 3386 #ifdef CONFIG_NET_KEY_MIGRATE ··· 3572 3572 } 3573 3573 3574 3574 /* broadcast migrate message to sockets */ 3575 - pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ALL, NULL, &init_net); 3575 + pfkey_broadcast(skb, BROADCAST_ALL, NULL, &init_net); 3576 3576 3577 3577 return 0; 3578 3578
+1 -1
net/netlink/af_netlink.c
··· 2401 2401 * sendmsg(), but that's what we've got... 2402 2402 */ 2403 2403 if (netlink_tx_is_mmaped(sk) && 2404 - msg->msg_iter.type == ITER_IOVEC && 2404 + iter_is_iovec(&msg->msg_iter) && 2405 2405 msg->msg_iter.nr_segs == 1 && 2406 2406 msg->msg_iter.iov->iov_base == NULL) { 2407 2407 err = netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group,
+13
net/sched/cls_u32.c
··· 490 490 return false; 491 491 } 492 492 } 493 + 494 + if (tp_c->refcnt > 1) 495 + return false; 496 + 497 + if (tp_c->refcnt == 1) { 498 + struct tc_u_hnode *ht; 499 + 500 + for (ht = rtnl_dereference(tp_c->hlist); 501 + ht; 502 + ht = rtnl_dereference(ht->next)) 503 + if (!ht_empty(ht)) 504 + return false; 505 + } 493 506 } 494 507 495 508 if (root_ht && --root_ht->refcnt == 0)
+7
net/sctp/sm_make_chunk.c
··· 3132 3132 case SCTP_PARAM_IPV4_ADDRESS: 3133 3133 if (length != sizeof(sctp_ipv4addr_param_t)) 3134 3134 return false; 3135 + /* ensure there is only one addr param and it's in the 3136 + * beginning of addip_hdr params, or we reject it. 3137 + */ 3138 + if (param.v != addip->addip_hdr.params) 3139 + return false; 3135 3140 addr_param_seen = true; 3136 3141 break; 3137 3142 case SCTP_PARAM_IPV6_ADDRESS: 3138 3143 if (length != sizeof(sctp_ipv6addr_param_t)) 3144 + return false; 3145 + if (param.v != addip->addip_hdr.params) 3139 3146 return false; 3140 3147 addr_param_seen = true; 3141 3148 break;
+1 -1
net/sctp/sm_sideeffect.c
··· 702 702 * outstanding data and rely on the retransmission limit be reached 703 703 * to shutdown the association. 704 704 */ 705 - if (t->asoc->state != SCTP_STATE_SHUTDOWN_PENDING) 705 + if (t->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) 706 706 t->asoc->overall_error_count = 0; 707 707 708 708 /* Clear the hb_sent flag to signal that we had a good