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:
"A quick batch of fixes, including the annoying bad lock stack problem
introduced by udp_sk_rx_dst_set() locking change:

1) Use xchg() instead of sk_dst_lock() in udp_sk_rx_dst_set(), from
Eric Dumazet.

2) qlcnic bug fixes from Himanshu Madhani and Manish Chopra.

3) Update IPSEC MAINTAINERS entry, from Steffen Klassert.

4) Administrative neigh entry changes should generate netlink
notifications the same as event generated ones. From Bob
Gilligan.

5) Netfilter SYNPROXY fixes from Patrick McHardy.

6) Netfilter nft_reject endianness fixes from Eric Leblond"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net:
qlcnic: Dump mailbox registers when mailbox command times out.
qlcnic: Fix mailbox processing during diagnostic test
qlcnic: Allow firmware dump collection when auto firmware recovery is disabled
qlcnic: Fix memory allocation
qlcnic: Fix TSS/RSS validation for 83xx/84xx series adapter.
qlcnic: Fix TSS/RSS ring validation logic.
qlcnic: Fix diagnostic test for all adapters.
qlcnic: Fix usage of netif_tx_{wake, stop} api during link change.
xen-netback: fix fragments error handling in checksum_setup_ip()
neigh: Netlink notification for administrative NUD state change
ipv4: improve documentation of ip_no_pmtu_disc
net: unix: allow bind to fail on mutex lock
MAINTAINERS: Update the IPsec maintainer entry
udp: ipv4: do not use sk_dst_lock from softirq context
netvsc: don't flush peers notifying work during setting mtu
can: peak_usb: fix mem leak in pcan_usb_pro_init()
can: ems_usb: fix urb leaks on failure paths
sctp: loading sctp when load sctp_probe
netfilter: nft_reject: fix endianness in dump function
netfilter: SYNPROXY target: restrict to INPUT/FORWARD

Linus Torvalds 8b803841 b0031f22

+128 -90
+6 -2
Documentation/networking/ip-sysctl.txt
··· 16 16 Default: 64 (as recommended by RFC1700) 17 17 18 18 ip_no_pmtu_disc - BOOLEAN 19 - Disable Path MTU Discovery. 20 - default FALSE 19 + Disable Path MTU Discovery. If enabled and a 20 + fragmentation-required ICMP is received, the PMTU to this 21 + destination will be set to min_pmtu (see below). You will need 22 + to raise min_pmtu to the smallest interface MTU on your system 23 + manually if you want to avoid locally generated fragments. 24 + Default: FALSE 21 25 22 26 min_pmtu - INTEGER 23 27 default 552 - minimum discovered Path MTU
+10 -1
MAINTAINERS
··· 5913 5913 M: Herbert Xu <herbert@gondor.apana.org.au> 5914 5914 M: "David S. Miller" <davem@davemloft.net> 5915 5915 L: netdev@vger.kernel.org 5916 - T: git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git 5916 + T: git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec.git 5917 + T: git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec-next.git 5917 5918 S: Maintained 5918 5919 F: net/xfrm/ 5919 5920 F: net/key/ 5920 5921 F: net/ipv4/xfrm* 5922 + F: net/ipv4/esp4.c 5923 + F: net/ipv4/ah4.c 5924 + F: net/ipv4/ipcomp.c 5925 + F: net/ipv4/ip_vti.c 5921 5926 F: net/ipv6/xfrm* 5927 + F: net/ipv6/esp6.c 5928 + F: net/ipv6/ah6.c 5929 + F: net/ipv6/ipcomp6.c 5930 + F: net/ipv6/ip6_vti.c 5922 5931 F: include/uapi/linux/xfrm.h 5923 5932 F: include/net/xfrm.h 5924 5933
+2 -1
drivers/net/can/usb/ems_usb.c
··· 625 625 usb_unanchor_urb(urb); 626 626 usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf, 627 627 urb->transfer_dma); 628 + usb_free_urb(urb); 628 629 break; 629 630 } 630 631 ··· 799 798 * allowed (MAX_TX_URBS). 800 799 */ 801 800 if (!context) { 802 - usb_unanchor_urb(urb); 803 801 usb_free_coherent(dev->udev, size, buf, urb->transfer_dma); 802 + usb_free_urb(urb); 804 803 805 804 netdev_warn(netdev, "couldn't find free context\n"); 806 805
+3
drivers/net/can/usb/peak_usb/pcan_usb_pro.c
··· 927 927 /* set LED in default state (end of init phase) */ 928 928 pcan_usb_pro_set_led(dev, 0, 1); 929 929 930 + kfree(bi); 931 + kfree(fi); 932 + 930 933 return 0; 931 934 932 935 err_out:
+21 -26
drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c
··· 447 447 448 448 qlcnic_83xx_poll_process_aen(adapter); 449 449 450 - if (ahw->diag_test == QLCNIC_INTERRUPT_TEST) { 451 - ahw->diag_cnt++; 450 + if (ahw->diag_test) { 451 + if (ahw->diag_test == QLCNIC_INTERRUPT_TEST) 452 + ahw->diag_cnt++; 452 453 qlcnic_83xx_enable_legacy_msix_mbx_intr(adapter); 453 454 return IRQ_HANDLED; 454 455 } ··· 1346 1345 } 1347 1346 1348 1347 if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) { 1349 - /* disable and free mailbox interrupt */ 1350 - if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) { 1351 - qlcnic_83xx_enable_mbx_poll(adapter); 1352 - qlcnic_83xx_free_mbx_intr(adapter); 1353 - } 1354 1348 adapter->ahw->loopback_state = 0; 1355 1349 adapter->ahw->hw_ops->setup_link_event(adapter, 1); 1356 1350 } ··· 1359 1363 { 1360 1364 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1361 1365 struct qlcnic_host_sds_ring *sds_ring; 1362 - int ring, err; 1366 + int ring; 1363 1367 1364 1368 clear_bit(__QLCNIC_DEV_UP, &adapter->state); 1365 1369 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) { 1366 1370 for (ring = 0; ring < adapter->drv_sds_rings; ring++) { 1367 1371 sds_ring = &adapter->recv_ctx->sds_rings[ring]; 1368 - qlcnic_83xx_disable_intr(adapter, sds_ring); 1369 - if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) 1370 - qlcnic_83xx_enable_mbx_poll(adapter); 1372 + if (adapter->flags & QLCNIC_MSIX_ENABLED) 1373 + qlcnic_83xx_disable_intr(adapter, sds_ring); 1371 1374 } 1372 1375 } 1373 1376 1374 1377 qlcnic_fw_destroy_ctx(adapter); 1375 1378 qlcnic_detach(adapter); 1376 1379 1377 - if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) { 1378 - if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) { 1379 - err = qlcnic_83xx_setup_mbx_intr(adapter); 1380 - qlcnic_83xx_disable_mbx_poll(adapter); 1381 - if (err) { 1382 - dev_err(&adapter->pdev->dev, 1383 - "%s: failed to setup mbx interrupt\n", 1384 - __func__); 1385 - goto out; 1386 - } 1387 - } 1388 - } 1389 1380 adapter->ahw->diag_test = 0; 1390 1381 adapter->drv_sds_rings = drv_sds_rings; 1391 1382 ··· 1382 1399 if (netif_running(netdev)) 1383 1400 __qlcnic_up(adapter, netdev); 1384 1401 1385 - if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST && 1386 - !(adapter->flags & QLCNIC_MSIX_ENABLED)) 1387 - qlcnic_83xx_disable_mbx_poll(adapter); 1388 1402 out: 1389 1403 netif_device_attach(netdev); 1390 1404 } ··· 3734 3754 return; 3735 3755 } 3736 3756 3757 + static inline void qlcnic_dump_mailbox_registers(struct qlcnic_adapter *adapter) 3758 + { 3759 + struct qlcnic_hardware_context *ahw = adapter->ahw; 3760 + u32 offset; 3761 + 3762 + offset = QLCRDX(ahw, QLCNIC_DEF_INT_MASK); 3763 + dev_info(&adapter->pdev->dev, "Mbx interrupt mask=0x%x, Mbx interrupt enable=0x%x, Host mbx control=0x%x, Fw mbx control=0x%x", 3764 + readl(ahw->pci_base0 + offset), 3765 + QLCRDX(ahw, QLCNIC_MBX_INTR_ENBL), 3766 + QLCRDX(ahw, QLCNIC_HOST_MBX_CTRL), 3767 + QLCRDX(ahw, QLCNIC_FW_MBX_CTRL)); 3768 + } 3769 + 3737 3770 static void qlcnic_83xx_mailbox_worker(struct work_struct *work) 3738 3771 { 3739 3772 struct qlcnic_mailbox *mbx = container_of(work, struct qlcnic_mailbox, ··· 3791 3798 __func__, cmd->cmd_op, cmd->type, ahw->pci_func, 3792 3799 ahw->op_mode); 3793 3800 clear_bit(QLC_83XX_MBX_READY, &mbx->status); 3801 + qlcnic_dump_mailbox_registers(adapter); 3802 + qlcnic_83xx_get_mbx_data(adapter, cmd); 3794 3803 qlcnic_dump_mbx(adapter, cmd); 3795 3804 qlcnic_83xx_idc_request_reset(adapter, 3796 3805 QLCNIC_FORCE_FW_DUMP_KEY);
+1
drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.h
··· 662 662 pci_channel_state_t); 663 663 pci_ers_result_t qlcnic_83xx_io_slot_reset(struct pci_dev *); 664 664 void qlcnic_83xx_io_resume(struct pci_dev *); 665 + void qlcnic_83xx_stop_hw(struct qlcnic_adapter *); 665 666 #endif
+41 -26
drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c
··· 740 740 adapter->ahw->idc.err_code = -EIO; 741 741 dev_err(&adapter->pdev->dev, 742 742 "%s: Device in unknown state\n", __func__); 743 + clear_bit(__QLCNIC_RESETTING, &adapter->state); 743 744 return 0; 744 745 } 745 746 ··· 819 818 struct qlcnic_hardware_context *ahw = adapter->ahw; 820 819 struct qlcnic_mailbox *mbx = ahw->mailbox; 821 820 int ret = 0; 822 - u32 owner; 823 821 u32 val; 824 822 825 823 /* Perform NIC configuration based ready state entry actions */ ··· 848 848 set_bit(__QLCNIC_RESETTING, &adapter->state); 849 849 qlcnic_83xx_idc_enter_need_reset_state(adapter, 1); 850 850 } else { 851 - owner = qlcnic_83xx_idc_find_reset_owner_id(adapter); 852 - if (ahw->pci_func == owner) 853 - qlcnic_dump_fw(adapter); 851 + netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n", 852 + __func__); 853 + qlcnic_83xx_idc_enter_failed_state(adapter, 1); 854 854 } 855 855 return -EIO; 856 856 } ··· 948 948 return 0; 949 949 } 950 950 951 - static int qlcnic_83xx_idc_failed_state(struct qlcnic_adapter *adapter) 951 + static void qlcnic_83xx_idc_failed_state(struct qlcnic_adapter *adapter) 952 952 { 953 - dev_err(&adapter->pdev->dev, "%s: please restart!!\n", __func__); 954 - clear_bit(__QLCNIC_RESETTING, &adapter->state); 955 - adapter->ahw->idc.err_code = -EIO; 953 + struct qlcnic_hardware_context *ahw = adapter->ahw; 954 + u32 val, owner; 956 955 957 - return 0; 956 + val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL); 957 + if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) { 958 + owner = qlcnic_83xx_idc_find_reset_owner_id(adapter); 959 + if (ahw->pci_func == owner) { 960 + qlcnic_83xx_stop_hw(adapter); 961 + qlcnic_dump_fw(adapter); 962 + } 963 + } 964 + 965 + netdev_warn(adapter->netdev, "%s: Reboot will be required to recover the adapter!!\n", 966 + __func__); 967 + clear_bit(__QLCNIC_RESETTING, &adapter->state); 968 + ahw->idc.err_code = -EIO; 969 + 970 + return; 958 971 } 959 972 960 973 static int qlcnic_83xx_idc_quiesce_state(struct qlcnic_adapter *adapter) ··· 1075 1062 } 1076 1063 adapter->ahw->idc.prev_state = adapter->ahw->idc.curr_state; 1077 1064 qlcnic_83xx_periodic_tasks(adapter); 1078 - 1079 - /* Do not reschedule if firmaware is in hanged state and auto 1080 - * recovery is disabled 1081 - */ 1082 - if ((adapter->flags & QLCNIC_FW_HANG) && !qlcnic_auto_fw_reset) 1083 - return; 1084 1065 1085 1066 /* Re-schedule the function */ 1086 1067 if (test_bit(QLC_83XX_MODULE_LOADED, &adapter->ahw->idc.status)) ··· 1226 1219 } 1227 1220 1228 1221 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL); 1229 - if ((val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) || 1230 - !qlcnic_auto_fw_reset) { 1231 - dev_err(&adapter->pdev->dev, 1232 - "%s:failed, device in non reset mode\n", __func__); 1222 + if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) { 1223 + netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n", 1224 + __func__); 1225 + qlcnic_83xx_idc_enter_failed_state(adapter, 0); 1233 1226 qlcnic_83xx_unlock_driver(adapter); 1234 1227 return; 1235 1228 } ··· 1261 1254 if (size & 0xF) 1262 1255 size = (size + 16) & ~0xF; 1263 1256 1264 - p_cache = kzalloc(size, GFP_KERNEL); 1257 + p_cache = vzalloc(size); 1265 1258 if (p_cache == NULL) 1266 1259 return -ENOMEM; 1267 1260 1268 1261 ret = qlcnic_83xx_lockless_flash_read32(adapter, src, p_cache, 1269 1262 size / sizeof(u32)); 1270 1263 if (ret) { 1271 - kfree(p_cache); 1264 + vfree(p_cache); 1272 1265 return ret; 1273 1266 } 1274 1267 /* 16 byte write to MS memory */ 1275 1268 ret = qlcnic_83xx_ms_mem_write128(adapter, dest, (u32 *)p_cache, 1276 1269 size / 16); 1277 1270 if (ret) { 1278 - kfree(p_cache); 1271 + vfree(p_cache); 1279 1272 return ret; 1280 1273 } 1281 - kfree(p_cache); 1274 + vfree(p_cache); 1282 1275 1283 1276 return ret; 1284 1277 } ··· 1946 1939 p_dev->ahw->reset.seq_index = index; 1947 1940 } 1948 1941 1949 - static void qlcnic_83xx_stop_hw(struct qlcnic_adapter *p_dev) 1942 + void qlcnic_83xx_stop_hw(struct qlcnic_adapter *p_dev) 1950 1943 { 1951 1944 p_dev->ahw->reset.seq_index = 0; 1952 1945 ··· 2001 1994 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL); 2002 1995 if (!(val & QLC_83XX_IDC_GRACEFULL_RESET)) 2003 1996 qlcnic_dump_fw(adapter); 1997 + 1998 + if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) { 1999 + netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n", 2000 + __func__); 2001 + qlcnic_83xx_idc_enter_failed_state(adapter, 1); 2002 + return err; 2003 + } 2004 + 2004 2005 qlcnic_83xx_init_hw(adapter); 2005 2006 2006 2007 if (qlcnic_83xx_copy_bootloader(adapter)) ··· 2088 2073 ahw->nic_mode = QLCNIC_DEFAULT_MODE; 2089 2074 adapter->nic_ops->init_driver = qlcnic_83xx_init_default_driver; 2090 2075 ahw->idc.state_entry = qlcnic_83xx_idc_ready_state_entry; 2091 - adapter->max_sds_rings = ahw->max_rx_ques; 2092 - adapter->max_tx_rings = ahw->max_tx_ques; 2076 + adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS; 2077 + adapter->max_tx_rings = QLCNIC_MAX_TX_RINGS; 2093 2078 } else { 2094 2079 return -EIO; 2095 2080 }
+8 -11
drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c
··· 667 667 static int qlcnic_validate_ring_count(struct qlcnic_adapter *adapter, 668 668 u8 rx_ring, u8 tx_ring) 669 669 { 670 + if (rx_ring == 0 || tx_ring == 0) 671 + return -EINVAL; 672 + 670 673 if (rx_ring != 0) { 671 674 if (rx_ring > adapter->max_sds_rings) { 672 - netdev_err(adapter->netdev, "Invalid ring count, SDS ring count %d should not be greater than max %d driver sds rings.\n", 675 + netdev_err(adapter->netdev, 676 + "Invalid ring count, SDS ring count %d should not be greater than max %d driver sds rings.\n", 673 677 rx_ring, adapter->max_sds_rings); 674 678 return -EINVAL; 675 679 } 676 680 } 677 681 678 682 if (tx_ring != 0) { 679 - if (qlcnic_82xx_check(adapter) && 680 - (tx_ring > adapter->max_tx_rings)) { 683 + if (tx_ring > adapter->max_tx_rings) { 681 684 netdev_err(adapter->netdev, 682 685 "Invalid ring count, Tx ring count %d should not be greater than max %d driver Tx rings.\n", 683 686 tx_ring, adapter->max_tx_rings); 684 687 return -EINVAL; 685 - } 686 - 687 - if (qlcnic_83xx_check(adapter) && 688 - (tx_ring > QLCNIC_SINGLE_RING)) { 689 - netdev_err(adapter->netdev, 690 - "Invalid ring count, Tx ring count %d should not be greater than %d driver Tx rings.\n", 691 - tx_ring, QLCNIC_SINGLE_RING); 692 - return -EINVAL; 693 688 } 694 689 } 695 690 ··· 943 948 struct qlcnic_hardware_context *ahw = adapter->ahw; 944 949 struct qlcnic_cmd_args cmd; 945 950 int ret, drv_sds_rings = adapter->drv_sds_rings; 951 + int drv_tx_rings = adapter->drv_tx_rings; 946 952 947 953 if (qlcnic_83xx_check(adapter)) 948 954 return qlcnic_83xx_interrupt_test(netdev); ··· 976 980 977 981 clear_diag_irq: 978 982 adapter->drv_sds_rings = drv_sds_rings; 983 + adapter->drv_tx_rings = drv_tx_rings; 979 984 clear_bit(__QLCNIC_RESETTING, &adapter->state); 980 985 981 986 return ret;
+2 -8
drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
··· 687 687 if (adapter->ahw->linkup && !linkup) { 688 688 netdev_info(netdev, "NIC Link is down\n"); 689 689 adapter->ahw->linkup = 0; 690 - if (netif_running(netdev)) { 691 - netif_carrier_off(netdev); 692 - netif_tx_stop_all_queues(netdev); 693 - } 690 + netif_carrier_off(netdev); 694 691 } else if (!adapter->ahw->linkup && linkup) { 695 692 netdev_info(netdev, "NIC Link is up\n"); 696 693 adapter->ahw->linkup = 1; 697 - if (netif_running(netdev)) { 698 - netif_carrier_on(netdev); 699 - netif_wake_queue(netdev); 700 - } 694 + netif_carrier_on(netdev); 701 695 } 702 696 } 703 697
+1 -1
drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
··· 1178 1178 } else { 1179 1179 adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE; 1180 1180 adapter->max_tx_rings = QLCNIC_MAX_HW_TX_RINGS; 1181 + adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS; 1181 1182 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED; 1182 1183 } 1183 1184 ··· 1941 1940 qlcnic_detach(adapter); 1942 1941 1943 1942 adapter->drv_sds_rings = QLCNIC_SINGLE_RING; 1944 - adapter->drv_tx_rings = QLCNIC_SINGLE_RING; 1945 1943 adapter->ahw->diag_test = test; 1946 1944 adapter->ahw->linkup = 0; 1947 1945
-1
drivers/net/hyperv/netvsc_drv.c
··· 327 327 return -EINVAL; 328 328 329 329 nvdev->start_remove = true; 330 - cancel_delayed_work_sync(&ndevctx->dwork); 331 330 cancel_work_sync(&ndevctx->work); 332 331 netif_tx_disable(ndev); 333 332 rndis_filter_device_remove(hdev);
+3
drivers/net/xen-netback/netback.c
··· 1197 1197 1198 1198 err = -EPROTO; 1199 1199 1200 + if (fragment) 1201 + goto out; 1202 + 1200 1203 switch (ip_hdr(skb)->protocol) { 1201 1204 case IPPROTO_TCP: 1202 1205 err = maybe_pull_tail(skb,
+1
net/core/neighbour.c
··· 1161 1161 neigh->parms->reachable_time : 1162 1162 0))); 1163 1163 neigh->nud_state = new; 1164 + notify = 1; 1164 1165 } 1165 1166 1166 1167 if (lladdr != neigh->ha) {
+1
net/ipv4/netfilter/ipt_SYNPROXY.c
··· 423 423 static struct xt_target synproxy_tg4_reg __read_mostly = { 424 424 .name = "SYNPROXY", 425 425 .family = NFPROTO_IPV4, 426 + .hooks = (1 << NF_INET_LOCAL_IN) | (1 << NF_INET_FORWARD), 426 427 .target = synproxy_tg4, 427 428 .targetsize = sizeof(struct xt_synproxy_info), 428 429 .checkentry = synproxy_tg4_check,
+1 -1
net/ipv4/netfilter/nft_reject_ipv4.c
··· 72 72 { 73 73 const struct nft_reject *priv = nft_expr_priv(expr); 74 74 75 - if (nla_put_be32(skb, NFTA_REJECT_TYPE, priv->type)) 75 + if (nla_put_be32(skb, NFTA_REJECT_TYPE, htonl(priv->type))) 76 76 goto nla_put_failure; 77 77 78 78 switch (priv->type) {
+4 -9
net/ipv4/udp.c
··· 1600 1600 } 1601 1601 1602 1602 /* For TCP sockets, sk_rx_dst is protected by socket lock 1603 - * For UDP, we use sk_dst_lock to guard against concurrent changes. 1603 + * For UDP, we use xchg() to guard against concurrent changes. 1604 1604 */ 1605 1605 static void udp_sk_rx_dst_set(struct sock *sk, struct dst_entry *dst) 1606 1606 { 1607 1607 struct dst_entry *old; 1608 1608 1609 - spin_lock(&sk->sk_dst_lock); 1610 - old = sk->sk_rx_dst; 1611 - if (likely(old != dst)) { 1612 - dst_hold(dst); 1613 - sk->sk_rx_dst = dst; 1614 - dst_release(old); 1615 - } 1616 - spin_unlock(&sk->sk_dst_lock); 1609 + dst_hold(dst); 1610 + old = xchg(&sk->sk_rx_dst, dst); 1611 + dst_release(old); 1617 1612 } 1618 1613 1619 1614 /*
+1
net/ipv6/netfilter/ip6t_SYNPROXY.c
··· 446 446 static struct xt_target synproxy_tg6_reg __read_mostly = { 447 447 .name = "SYNPROXY", 448 448 .family = NFPROTO_IPV6, 449 + .hooks = (1 << NF_INET_LOCAL_IN) | (1 << NF_INET_FORWARD), 449 450 .target = synproxy_tg6, 450 451 .targetsize = sizeof(struct xt_synproxy_info), 451 452 .checkentry = synproxy_tg6_check,
+16 -1
net/sctp/probe.c
··· 38 38 #include <net/sctp/sctp.h> 39 39 #include <net/sctp/sm.h> 40 40 41 + MODULE_SOFTDEP("pre: sctp"); 41 42 MODULE_AUTHOR("Wei Yongjun <yjwei@cn.fujitsu.com>"); 42 43 MODULE_DESCRIPTION("SCTP snooper"); 43 44 MODULE_LICENSE("GPL"); ··· 183 182 .entry = jsctp_sf_eat_sack, 184 183 }; 185 184 185 + static __init int sctp_setup_jprobe(void) 186 + { 187 + int ret = register_jprobe(&sctp_recv_probe); 188 + 189 + if (ret) { 190 + if (request_module("sctp")) 191 + goto out; 192 + ret = register_jprobe(&sctp_recv_probe); 193 + } 194 + 195 + out: 196 + return ret; 197 + } 198 + 186 199 static __init int sctpprobe_init(void) 187 200 { 188 201 int ret = -ENOMEM; ··· 217 202 &sctpprobe_fops)) 218 203 goto free_kfifo; 219 204 220 - ret = register_jprobe(&sctp_recv_probe); 205 + ret = sctp_setup_jprobe(); 221 206 if (ret) 222 207 goto remove_proc; 223 208
+6 -2
net/unix/af_unix.c
··· 718 718 int err; 719 719 unsigned int retries = 0; 720 720 721 - mutex_lock(&u->readlock); 721 + err = mutex_lock_interruptible(&u->readlock); 722 + if (err) 723 + return err; 722 724 723 725 err = 0; 724 726 if (u->addr) ··· 879 877 goto out; 880 878 addr_len = err; 881 879 882 - mutex_lock(&u->readlock); 880 + err = mutex_lock_interruptible(&u->readlock); 881 + if (err) 882 + goto out; 883 883 884 884 err = -EINVAL; 885 885 if (u->addr)