Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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:
e100: Use pci_pme_active to clear PME_Status and disable PME#
e1000: prevent corruption of EEPROM/NVM
forcedeth: call restore mac addr in nv_shutdown path
bnx2: Promote vector field in bnx2_irq structure from u16 to unsigned int
sctp: Fix oops when INIT-ACK indicates that peer doesn't support AUTH
sctp: do not enable peer features if we can't do them.
sctp: set the skb->ip_summed correctly when sending over loopback.
udp: Fix rcv socket locking
+87
-47
+1
-1
drivers/net/bnx2.h
+1
-1
drivers/net/bnx2.h
+1
-3
drivers/net/e100.c
+1
-3
drivers/net/e100.c
···
2738
2738
nic->flags |= wol_magic;
2739
2739
2740
2740
/* ack any pending wake events, disable PME */
2741
-
err = pci_enable_wake(pdev, 0, 0);
2742
-
if (err)
2743
-
DPRINTK(PROBE, ERR, "Error clearing wake event\n");
2741
+
pci_pme_active(pdev, false);
2744
2742
2745
2743
strcpy(netdev->name, "eth%d");
2746
2744
if((err = register_netdev(netdev))) {
+23
drivers/net/e1000/e1000_hw.c
+23
drivers/net/e1000/e1000_hw.c
···
144
144
static u8 e1000_calculate_mng_checksum(char *buffer, u32 length);
145
145
static s32 e1000_configure_kmrn_for_10_100(struct e1000_hw *hw, u16 duplex);
146
146
static s32 e1000_configure_kmrn_for_1000(struct e1000_hw *hw);
147
+
static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data);
148
+
static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data);
147
149
148
150
/* IGP cable length table */
149
151
static const
···
169
167
60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
170
168
83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
171
169
104, 109, 114, 118, 121, 124};
170
+
171
+
static DEFINE_SPINLOCK(e1000_eeprom_lock);
172
172
173
173
/******************************************************************************
174
174
* Set the phy type member in the hw struct.
···
4908
4904
*****************************************************************************/
4909
4905
s32 e1000_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
4910
4906
{
4907
+
s32 ret;
4908
+
spin_lock(&e1000_eeprom_lock);
4909
+
ret = e1000_do_read_eeprom(hw, offset, words, data);
4910
+
spin_unlock(&e1000_eeprom_lock);
4911
+
return ret;
4912
+
}
4913
+
4914
+
static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
4915
+
{
4911
4916
struct e1000_eeprom_info *eeprom = &hw->eeprom;
4912
4917
u32 i = 0;
4913
4918
···
5248
5235
* EEPROM will most likely contain an invalid checksum.
5249
5236
*****************************************************************************/
5250
5237
s32 e1000_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
5238
+
{
5239
+
s32 ret;
5240
+
spin_lock(&e1000_eeprom_lock);
5241
+
ret = e1000_do_write_eeprom(hw, offset, words, data);
5242
+
spin_unlock(&e1000_eeprom_lock);
5243
+
return ret;
5244
+
}
5245
+
5246
+
5247
+
static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
5251
5248
{
5252
5249
struct e1000_eeprom_info *eeprom = &hw->eeprom;
5253
5250
s32 status = 0;
+13
-3
drivers/net/forcedeth.c
+13
-3
drivers/net/forcedeth.c
···
5643
5643
dev->dev_addr[4] = (np->orig_mac[0] >> 8) & 0xff;
5644
5644
dev->dev_addr[5] = (np->orig_mac[0] >> 0) & 0xff;
5645
5645
writel(txreg|NVREG_TRANSMITPOLL_MAC_ADDR_REV, base + NvRegTransmitPoll);
5646
+
printk(KERN_DEBUG "nv_probe: set workaround bit for reversed mac addr\n");
5646
5647
}
5647
5648
memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
5648
5649
···
5891
5890
}
5892
5891
}
5893
5892
5894
-
static void __devexit nv_remove(struct pci_dev *pci_dev)
5893
+
static void nv_restore_mac_addr(struct pci_dev *pci_dev)
5895
5894
{
5896
5895
struct net_device *dev = pci_get_drvdata(pci_dev);
5897
5896
struct fe_priv *np = netdev_priv(dev);
5898
5897
u8 __iomem *base = get_hwbase(dev);
5899
-
5900
-
unregister_netdev(dev);
5901
5898
5902
5899
/* special op: write back the misordered MAC address - otherwise
5903
5900
* the next nv_probe would see a wrong address.
···
5904
5905
writel(np->orig_mac[1], base + NvRegMacAddrB);
5905
5906
writel(readl(base + NvRegTransmitPoll) & ~NVREG_TRANSMITPOLL_MAC_ADDR_REV,
5906
5907
base + NvRegTransmitPoll);
5908
+
}
5909
+
5910
+
static void __devexit nv_remove(struct pci_dev *pci_dev)
5911
+
{
5912
+
struct net_device *dev = pci_get_drvdata(pci_dev);
5913
+
5914
+
unregister_netdev(dev);
5915
+
5916
+
nv_restore_mac_addr(pci_dev);
5907
5917
5908
5918
/* restore any phy related changes */
5909
5919
nv_restore_phy(dev);
···
5982
5974
5983
5975
if (netif_running(dev))
5984
5976
nv_close(dev);
5977
+
5978
+
nv_restore_mac_addr(pdev);
5985
5979
5986
5980
pci_disable_device(pdev);
5987
5981
if (system_state == SYSTEM_POWER_OFF) {
+33
-29
net/ipv4/udp.c
+33
-29
net/ipv4/udp.c
···
951
951
return 0;
952
952
}
953
953
954
+
static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
955
+
{
956
+
int is_udplite = IS_UDPLITE(sk);
957
+
int rc;
958
+
959
+
if ((rc = sock_queue_rcv_skb(sk, skb)) < 0) {
960
+
/* Note that an ENOMEM error is charged twice */
961
+
if (rc == -ENOMEM)
962
+
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
963
+
is_udplite);
964
+
goto drop;
965
+
}
966
+
967
+
return 0;
968
+
969
+
drop:
970
+
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
971
+
kfree_skb(skb);
972
+
return -1;
973
+
}
974
+
954
975
/* returns:
955
976
* -1: error
956
977
* 0: success
···
1010
989
up->encap_rcv != NULL) {
1011
990
int ret;
1012
991
1013
-
bh_unlock_sock(sk);
1014
992
ret = (*up->encap_rcv)(sk, skb);
1015
-
bh_lock_sock(sk);
1016
993
if (ret <= 0) {
1017
994
UDP_INC_STATS_BH(sock_net(sk),
1018
995
UDP_MIB_INDATAGRAMS,
···
1063
1044
goto drop;
1064
1045
}
1065
1046
1066
-
if ((rc = sock_queue_rcv_skb(sk,skb)) < 0) {
1067
-
/* Note that an ENOMEM error is charged twice */
1068
-
if (rc == -ENOMEM) {
1069
-
UDP_INC_STATS_BH(sock_net(sk),
1070
-
UDP_MIB_RCVBUFERRORS, is_udplite);
1071
-
atomic_inc(&sk->sk_drops);
1072
-
}
1073
-
goto drop;
1074
-
}
1047
+
rc = 0;
1075
1048
1076
-
return 0;
1049
+
bh_lock_sock(sk);
1050
+
if (!sock_owned_by_user(sk))
1051
+
rc = __udp_queue_rcv_skb(sk, skb);
1052
+
else
1053
+
sk_add_backlog(sk, skb);
1054
+
bh_unlock_sock(sk);
1055
+
1056
+
return rc;
1077
1057
1078
1058
drop:
1079
1059
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
···
1110
1092
skb1 = skb_clone(skb, GFP_ATOMIC);
1111
1093
1112
1094
if (skb1) {
1113
-
int ret = 0;
1114
-
1115
-
bh_lock_sock(sk);
1116
-
if (!sock_owned_by_user(sk))
1117
-
ret = udp_queue_rcv_skb(sk, skb1);
1118
-
else
1119
-
sk_add_backlog(sk, skb1);
1120
-
bh_unlock_sock(sk);
1121
-
1095
+
int ret = udp_queue_rcv_skb(sk, skb1);
1122
1096
if (ret > 0)
1123
1097
/* we should probably re-process instead
1124
1098
* of dropping packets here. */
···
1205
1195
uh->dest, inet_iif(skb), udptable);
1206
1196
1207
1197
if (sk != NULL) {
1208
-
int ret = 0;
1209
-
bh_lock_sock(sk);
1210
-
if (!sock_owned_by_user(sk))
1211
-
ret = udp_queue_rcv_skb(sk, skb);
1212
-
else
1213
-
sk_add_backlog(sk, skb);
1214
-
bh_unlock_sock(sk);
1198
+
int ret = udp_queue_rcv_skb(sk, skb);
1215
1199
sock_put(sk);
1216
1200
1217
1201
/* a return value > 0 means to resubmit the input, but
···
1498
1494
.sendmsg = udp_sendmsg,
1499
1495
.recvmsg = udp_recvmsg,
1500
1496
.sendpage = udp_sendpage,
1501
-
.backlog_rcv = udp_queue_rcv_skb,
1497
+
.backlog_rcv = __udp_queue_rcv_skb,
1502
1498
.hash = udp_lib_hash,
1503
1499
.unhash = udp_lib_unhash,
1504
1500
.get_port = udp_v4_get_port,
+5
-4
net/sctp/associola.c
+5
-4
net/sctp/associola.c
···
599
599
/* Check to see if this is a duplicate. */
600
600
peer = sctp_assoc_lookup_paddr(asoc, addr);
601
601
if (peer) {
602
+
/* An UNKNOWN state is only set on transports added by
603
+
* user in sctp_connectx() call. Such transports should be
604
+
* considered CONFIRMED per RFC 4960, Section 5.4.
605
+
*/
602
606
if (peer->state == SCTP_UNKNOWN) {
603
-
if (peer_state == SCTP_ACTIVE)
604
-
peer->state = SCTP_ACTIVE;
605
-
if (peer_state == SCTP_UNCONFIRMED)
606
-
peer->state = SCTP_UNCONFIRMED;
607
+
peer->state = SCTP_ACTIVE;
607
608
}
608
609
return peer;
609
610
}
+2
-1
net/sctp/output.c
+2
-1
net/sctp/output.c
···
533
533
if (!(dst->dev->features & NETIF_F_NO_CSUM)) {
534
534
crc32 = sctp_start_cksum((__u8 *)sh, cksum_buf_len);
535
535
crc32 = sctp_end_cksum(crc32);
536
-
}
536
+
} else
537
+
nskb->ip_summed = CHECKSUM_UNNECESSARY;
537
538
538
539
/* 3) Put the resultant value into the checksum field in the
539
540
* common header, and leave the rest of the bits unchanged.
+9
-6
net/sctp/sm_make_chunk.c
+9
-6
net/sctp/sm_make_chunk.c
···
1886
1886
/* if the peer reports AUTH, assume that he
1887
1887
* supports AUTH.
1888
1888
*/
1889
-
asoc->peer.auth_capable = 1;
1889
+
if (sctp_auth_enable)
1890
+
asoc->peer.auth_capable = 1;
1890
1891
break;
1891
1892
case SCTP_CID_ASCONF:
1892
1893
case SCTP_CID_ASCONF_ACK:
1893
-
asoc->peer.asconf_capable = 1;
1894
+
if (sctp_addip_enable)
1895
+
asoc->peer.asconf_capable = 1;
1894
1896
break;
1895
1897
default:
1896
1898
break;
···
2321
2319
/* Release the transport structures. */
2322
2320
list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
2323
2321
transport = list_entry(pos, struct sctp_transport, transports);
2324
-
list_del_init(pos);
2325
-
sctp_transport_free(transport);
2322
+
if (transport->state != SCTP_ACTIVE)
2323
+
sctp_assoc_rm_peer(asoc, transport);
2326
2324
}
2327
-
2328
-
asoc->peer.transport_count = 0;
2329
2325
2330
2326
nomem:
2331
2327
return 0;
···
2460
2460
break;
2461
2461
2462
2462
case SCTP_PARAM_SET_PRIMARY:
2463
+
if (!sctp_addip_enable)
2464
+
goto fall_through;
2465
+
2463
2466
addr_param = param.v + sizeof(sctp_addip_param_t);
2464
2467
2465
2468
af = sctp_get_af_specific(param_type2af(param.p->type));