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:
[TOKENRING]: rif_timer not initialized properly
[NETFILTER]: bridge: fix double POST_ROUTING invocation
[NETFILTER]: xt_helper: Do not bypass RCU
[NETFILTER]: ip6t_eui64: Fixes calculation of Universal/Local bit
[MACVLAN]: Prevent nesting macvlan devices
[VLAN]: nested VLAN: fix lockdep's recursive locking warning
[DECNET] ROUTE: fix rcu_dereference() uses in /proc/net/decnet_cache
[BLUETOOTH]: Always send explicit hci_ll wake-up acks.
[BLUETOOTH]: rfcomm tty BUG_ON() code fix
[AX25] af_ax25: Possible circular locking.
[AX25]: Kill user triggable printks.
[IPV4] ROUTE: fix rcu_dereference() uses in /proc/net/rt_cache
[NEIGH]: Fix race between neigh_parms_release and neightbl_fill_parms
[NIU]: Support for Marvell PHY
+326
-79
+14
-9
drivers/bluetooth/hci_ll.c
+14
-9
drivers/bluetooth/hci_ll.c
···
204
204
spin_lock_irqsave(&ll->hcill_lock, flags);
205
205
206
206
switch (ll->hcill_state) {
207
+
case HCILL_ASLEEP_TO_AWAKE:
208
+
/*
209
+
* This state means that both the host and the BRF chip
210
+
* have simultaneously sent a wake-up-indication packet.
211
+
* Traditionaly, in this case, receiving a wake-up-indication
212
+
* was enough and an additional wake-up-ack wasn't needed.
213
+
* This has changed with the BRF6350, which does require an
214
+
* explicit wake-up-ack. Other BRF versions, which do not
215
+
* require an explicit ack here, do accept it, thus it is
216
+
* perfectly safe to always send one.
217
+
*/
218
+
BT_DBG("dual wake-up-indication");
219
+
/* deliberate fall-through - do not add break */
207
220
case HCILL_ASLEEP:
208
221
/* acknowledge device wake up */
209
222
if (send_hcill_cmd(HCILL_WAKE_UP_ACK, hu) < 0) {
···
224
211
goto out;
225
212
}
226
213
break;
227
-
case HCILL_ASLEEP_TO_AWAKE:
228
-
/*
229
-
* this state means that a wake-up-indication
230
-
* is already on its way to the device,
231
-
* and will serve as the required wake-up-ack
232
-
*/
233
-
BT_DBG("dual wake-up-indication");
234
-
break;
235
214
default:
236
-
/* any other state are illegal */
215
+
/* any other state is illegal */
237
216
BT_ERR("received HCILL_WAKE_UP_IND in state %ld", ll->hcill_state);
238
217
break;
239
218
}
+7
drivers/net/macvlan.c
+7
drivers/net/macvlan.c
···
384
384
if (lowerdev == NULL)
385
385
return -ENODEV;
386
386
387
+
/* Don't allow macvlans on top of other macvlans - its not really
388
+
* wrong, but lockdep can't handle it and its not useful for anything
389
+
* you couldn't do directly on top of the real device.
390
+
*/
391
+
if (lowerdev->rtnl_link_ops == dev->rtnl_link_ops)
392
+
return -ENODEV;
393
+
387
394
if (!tb[IFLA_MTU])
388
395
dev->mtu = lowerdev->mtu;
389
396
else if (dev->mtu > lowerdev->mtu)
+199
-21
drivers/net/niu.c
+199
-21
drivers/net/niu.c
···
801
801
return 0;
802
802
}
803
803
804
-
static int xcvr_init_10g(struct niu *np)
804
+
static int mrvl88x2011_act_led(struct niu *np, int val)
805
+
{
806
+
int err;
807
+
808
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
809
+
MRVL88X2011_LED_8_TO_11_CTL);
810
+
if (err < 0)
811
+
return err;
812
+
813
+
err &= ~MRVL88X2011_LED(MRVL88X2011_LED_ACT,MRVL88X2011_LED_CTL_MASK);
814
+
err |= MRVL88X2011_LED(MRVL88X2011_LED_ACT,val);
815
+
816
+
return mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
817
+
MRVL88X2011_LED_8_TO_11_CTL, err);
818
+
}
819
+
820
+
static int mrvl88x2011_led_blink_rate(struct niu *np, int rate)
821
+
{
822
+
int err;
823
+
824
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
825
+
MRVL88X2011_LED_BLINK_CTL);
826
+
if (err >= 0) {
827
+
err &= ~MRVL88X2011_LED_BLKRATE_MASK;
828
+
err |= (rate << 4);
829
+
830
+
err = mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
831
+
MRVL88X2011_LED_BLINK_CTL, err);
832
+
}
833
+
834
+
return err;
835
+
}
836
+
837
+
static int xcvr_init_10g_mrvl88x2011(struct niu *np)
838
+
{
839
+
int err;
840
+
841
+
/* Set LED functions */
842
+
err = mrvl88x2011_led_blink_rate(np, MRVL88X2011_LED_BLKRATE_134MS);
843
+
if (err)
844
+
return err;
845
+
846
+
/* led activity */
847
+
err = mrvl88x2011_act_led(np, MRVL88X2011_LED_CTL_OFF);
848
+
if (err)
849
+
return err;
850
+
851
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
852
+
MRVL88X2011_GENERAL_CTL);
853
+
if (err < 0)
854
+
return err;
855
+
856
+
err |= MRVL88X2011_ENA_XFPREFCLK;
857
+
858
+
err = mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
859
+
MRVL88X2011_GENERAL_CTL, err);
860
+
if (err < 0)
861
+
return err;
862
+
863
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
864
+
MRVL88X2011_PMA_PMD_CTL_1);
865
+
if (err < 0)
866
+
return err;
867
+
868
+
if (np->link_config.loopback_mode == LOOPBACK_MAC)
869
+
err |= MRVL88X2011_LOOPBACK;
870
+
else
871
+
err &= ~MRVL88X2011_LOOPBACK;
872
+
873
+
err = mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
874
+
MRVL88X2011_PMA_PMD_CTL_1, err);
875
+
if (err < 0)
876
+
return err;
877
+
878
+
/* Enable PMD */
879
+
return mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
880
+
MRVL88X2011_10G_PMD_TX_DIS, MRVL88X2011_ENA_PMDTX);
881
+
}
882
+
883
+
static int xcvr_init_10g_bcm8704(struct niu *np)
805
884
{
806
885
struct niu_link_config *lp = &np->link_config;
807
886
u16 analog_stat0, tx_alarm_status;
808
887
int err;
809
-
u64 val;
810
-
811
-
val = nr64_mac(XMAC_CONFIG);
812
-
val &= ~XMAC_CONFIG_LED_POLARITY;
813
-
val |= XMAC_CONFIG_FORCE_LED_ON;
814
-
nw64_mac(XMAC_CONFIG, val);
815
-
816
-
/* XXX shared resource, lock parent XXX */
817
-
val = nr64(MIF_CONFIG);
818
-
val |= MIF_CONFIG_INDIRECT_MODE;
819
-
nw64(MIF_CONFIG, val);
820
888
821
889
err = bcm8704_reset(np);
822
890
if (err)
···
959
891
pr_info(PFX "Port %u optical module is bad "
960
892
"or missing.\n", np->port);
961
893
}
894
+
}
895
+
896
+
return 0;
897
+
}
898
+
899
+
static int xcvr_init_10g(struct niu *np)
900
+
{
901
+
int phy_id, err;
902
+
u64 val;
903
+
904
+
val = nr64_mac(XMAC_CONFIG);
905
+
val &= ~XMAC_CONFIG_LED_POLARITY;
906
+
val |= XMAC_CONFIG_FORCE_LED_ON;
907
+
nw64_mac(XMAC_CONFIG, val);
908
+
909
+
/* XXX shared resource, lock parent XXX */
910
+
val = nr64(MIF_CONFIG);
911
+
val |= MIF_CONFIG_INDIRECT_MODE;
912
+
nw64(MIF_CONFIG, val);
913
+
914
+
phy_id = phy_decode(np->parent->port_phy, np->port);
915
+
phy_id = np->parent->phy_probe_info.phy_id[phy_id][np->port];
916
+
917
+
/* handle different phy types */
918
+
switch (phy_id & NIU_PHY_ID_MASK) {
919
+
case NIU_PHY_ID_MRVL88X2011:
920
+
err = xcvr_init_10g_mrvl88x2011(np);
921
+
break;
922
+
923
+
default: /* bcom 8704 */
924
+
err = xcvr_init_10g_bcm8704(np);
925
+
break;
962
926
}
963
927
964
928
return 0;
···
1182
1082
return 0;
1183
1083
}
1184
1084
1185
-
static int link_status_10g(struct niu *np, int *link_up_p)
1085
+
static int link_status_10g_mrvl(struct niu *np, int *link_up_p)
1186
1086
{
1187
-
unsigned long flags;
1188
-
int err, link_up;
1087
+
int err, link_up, pma_status, pcs_status;
1189
1088
1190
1089
link_up = 0;
1191
1090
1192
-
spin_lock_irqsave(&np->lock, flags);
1193
-
1194
-
err = -EINVAL;
1195
-
if (np->link_config.loopback_mode != LOOPBACK_DISABLED)
1091
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
1092
+
MRVL88X2011_10G_PMD_STATUS_2);
1093
+
if (err < 0)
1196
1094
goto out;
1095
+
1096
+
/* Check PMA/PMD Register: 1.0001.2 == 1 */
1097
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
1098
+
MRVL88X2011_PMA_PMD_STATUS_1);
1099
+
if (err < 0)
1100
+
goto out;
1101
+
1102
+
pma_status = ((err & MRVL88X2011_LNK_STATUS_OK) ? 1 : 0);
1103
+
1104
+
/* Check PMC Register : 3.0001.2 == 1: read twice */
1105
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
1106
+
MRVL88X2011_PMA_PMD_STATUS_1);
1107
+
if (err < 0)
1108
+
goto out;
1109
+
1110
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
1111
+
MRVL88X2011_PMA_PMD_STATUS_1);
1112
+
if (err < 0)
1113
+
goto out;
1114
+
1115
+
pcs_status = ((err & MRVL88X2011_LNK_STATUS_OK) ? 1 : 0);
1116
+
1117
+
/* Check XGXS Register : 4.0018.[0-3,12] */
1118
+
err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV4_ADDR,
1119
+
MRVL88X2011_10G_XGXS_LANE_STAT);
1120
+
if (err < 0)
1121
+
goto out;
1122
+
1123
+
if (err == (PHYXS_XGXS_LANE_STAT_ALINGED | PHYXS_XGXS_LANE_STAT_LANE3 |
1124
+
PHYXS_XGXS_LANE_STAT_LANE2 | PHYXS_XGXS_LANE_STAT_LANE1 |
1125
+
PHYXS_XGXS_LANE_STAT_LANE0 | PHYXS_XGXS_LANE_STAT_MAGIC |
1126
+
0x800))
1127
+
link_up = (pma_status && pcs_status) ? 1 : 0;
1128
+
1129
+
np->link_config.active_speed = SPEED_10000;
1130
+
np->link_config.active_duplex = DUPLEX_FULL;
1131
+
err = 0;
1132
+
out:
1133
+
mrvl88x2011_act_led(np, (link_up ?
1134
+
MRVL88X2011_LED_CTL_PCS_ACT :
1135
+
MRVL88X2011_LED_CTL_OFF));
1136
+
1137
+
*link_up_p = link_up;
1138
+
return err;
1139
+
}
1140
+
1141
+
static int link_status_10g_bcom(struct niu *np, int *link_up_p)
1142
+
{
1143
+
int err, link_up;
1144
+
1145
+
link_up = 0;
1197
1146
1198
1147
err = mdio_read(np, np->phy_addr, BCM8704_PMA_PMD_DEV_ADDR,
1199
1148
BCM8704_PMD_RCV_SIGDET);
···
1283
1134
err = 0;
1284
1135
1285
1136
out:
1137
+
*link_up_p = link_up;
1138
+
return err;
1139
+
}
1140
+
1141
+
static int link_status_10g(struct niu *np, int *link_up_p)
1142
+
{
1143
+
unsigned long flags;
1144
+
int err = -EINVAL;
1145
+
1146
+
spin_lock_irqsave(&np->lock, flags);
1147
+
1148
+
if (np->link_config.loopback_mode == LOOPBACK_DISABLED) {
1149
+
int phy_id;
1150
+
1151
+
phy_id = phy_decode(np->parent->port_phy, np->port);
1152
+
phy_id = np->parent->phy_probe_info.phy_id[phy_id][np->port];
1153
+
1154
+
/* handle different phy types */
1155
+
switch (phy_id & NIU_PHY_ID_MASK) {
1156
+
case NIU_PHY_ID_MRVL88X2011:
1157
+
err = link_status_10g_mrvl(np, link_up_p);
1158
+
break;
1159
+
1160
+
default: /* bcom 8704 */
1161
+
err = link_status_10g_bcom(np, link_up_p);
1162
+
break;
1163
+
}
1164
+
}
1165
+
1286
1166
spin_unlock_irqrestore(&np->lock, flags);
1287
1167
1288
-
*link_up_p = link_up;
1289
1168
return err;
1290
1169
}
1291
1170
···
6474
6297
if (dev_id_1 < 0 || dev_id_2 < 0)
6475
6298
return 0;
6476
6299
if (type == PHY_TYPE_PMA_PMD || type == PHY_TYPE_PCS) {
6477
-
if ((id & NIU_PHY_ID_MASK) != NIU_PHY_ID_BCM8704)
6300
+
if (((id & NIU_PHY_ID_MASK) != NIU_PHY_ID_BCM8704) &&
6301
+
((id & NIU_PHY_ID_MASK) != NIU_PHY_ID_MRVL88X2011))
6478
6302
return 0;
6479
6303
} else {
6480
6304
if ((id & NIU_PHY_ID_MASK) != NIU_PHY_ID_BCM5464R)
+33
drivers/net/niu.h
+33
drivers/net/niu.h
···
2538
2538
#define NIU_PHY_ID_MASK 0xfffff0f0
2539
2539
#define NIU_PHY_ID_BCM8704 0x00206030
2540
2540
#define NIU_PHY_ID_BCM5464R 0x002060b0
2541
+
#define NIU_PHY_ID_MRVL88X2011 0x01410020
2542
+
2543
+
/* MRVL88X2011 register addresses */
2544
+
#define MRVL88X2011_USER_DEV1_ADDR 1
2545
+
#define MRVL88X2011_USER_DEV2_ADDR 2
2546
+
#define MRVL88X2011_USER_DEV3_ADDR 3
2547
+
#define MRVL88X2011_USER_DEV4_ADDR 4
2548
+
#define MRVL88X2011_PMA_PMD_CTL_1 0x0000
2549
+
#define MRVL88X2011_PMA_PMD_STATUS_1 0x0001
2550
+
#define MRVL88X2011_10G_PMD_STATUS_2 0x0008
2551
+
#define MRVL88X2011_10G_PMD_TX_DIS 0x0009
2552
+
#define MRVL88X2011_10G_XGXS_LANE_STAT 0x0018
2553
+
#define MRVL88X2011_GENERAL_CTL 0x8300
2554
+
#define MRVL88X2011_LED_BLINK_CTL 0x8303
2555
+
#define MRVL88X2011_LED_8_TO_11_CTL 0x8306
2556
+
2557
+
/* MRVL88X2011 register control */
2558
+
#define MRVL88X2011_ENA_XFPREFCLK 0x0001
2559
+
#define MRVL88X2011_ENA_PMDTX 0x0000
2560
+
#define MRVL88X2011_LOOPBACK 0x1
2561
+
#define MRVL88X2011_LED_ACT 0x1
2562
+
#define MRVL88X2011_LNK_STATUS_OK 0x4
2563
+
#define MRVL88X2011_LED_BLKRATE_MASK 0x70
2564
+
#define MRVL88X2011_LED_BLKRATE_034MS 0x0
2565
+
#define MRVL88X2011_LED_BLKRATE_067MS 0x1
2566
+
#define MRVL88X2011_LED_BLKRATE_134MS 0x2
2567
+
#define MRVL88X2011_LED_BLKRATE_269MS 0x3
2568
+
#define MRVL88X2011_LED_BLKRATE_538MS 0x4
2569
+
#define MRVL88X2011_LED_CTL_OFF 0x0
2570
+
#define MRVL88X2011_LED_CTL_PCS_ACT 0x5
2571
+
#define MRVL88X2011_LED_CTL_MASK 0x7
2572
+
#define MRVL88X2011_LED(n,v) ((v)<<((n)*4))
2573
+
#define MRVL88X2011_LED_STAT(n,v) ((v)>>((n)*4))
2541
2574
2542
2575
#define BCM8704_PMA_PMD_DEV_ADDR 1
2543
2576
#define BCM8704_PCS_DEV_ADDR 2
+1
-1
net/802/tr.c
+1
-1
net/802/tr.c
···
642
642
static int __init rif_init(void)
643
643
{
644
644
init_timer(&rif_timer);
645
-
rif_timer.expires = sysctl_tr_rif_timeout;
645
+
rif_timer.expires = jiffies + sysctl_tr_rif_timeout;
646
646
rif_timer.data = 0L;
647
647
rif_timer.function = rif_check_expire;
648
648
add_timer(&rif_timer);
+6
-1
net/8021q/vlan.c
+6
-1
net/8021q/vlan.c
···
323
323
static int vlan_dev_init(struct net_device *dev)
324
324
{
325
325
struct net_device *real_dev = VLAN_DEV_INFO(dev)->real_dev;
326
+
int subclass = 0;
326
327
327
328
/* IFF_BROADCAST|IFF_MULTICAST; ??? */
328
329
dev->flags = real_dev->flags & ~IFF_UP;
···
350
349
dev->hard_start_xmit = vlan_dev_hard_start_xmit;
351
350
}
352
351
353
-
lockdep_set_class(&dev->_xmit_lock, &vlan_netdev_xmit_lock_key);
352
+
if (real_dev->priv_flags & IFF_802_1Q_VLAN)
353
+
subclass = 1;
354
+
355
+
lockdep_set_class_and_subclass(&dev->_xmit_lock,
356
+
&vlan_netdev_xmit_lock_key, subclass);
354
357
return 0;
355
358
}
356
359
+30
-21
net/ax25/af_ax25.c
+30
-21
net/ax25/af_ax25.c
···
87
87
return;
88
88
89
89
spin_lock_bh(&ax25_list_lock);
90
+
again:
90
91
ax25_for_each(s, node, &ax25_list) {
91
92
if (s->ax25_dev == ax25_dev) {
92
93
s->ax25_dev = NULL;
94
+
spin_unlock_bh(&ax25_list_lock);
93
95
ax25_disconnect(s, ENETUNREACH);
96
+
spin_lock_bh(&ax25_list_lock);
97
+
98
+
/* The entry could have been deleted from the
99
+
* list meanwhile and thus the next pointer is
100
+
* no longer valid. Play it safe and restart
101
+
* the scan. Forward progress is ensured
102
+
* because we set s->ax25_dev to NULL and we
103
+
* are never passed a NULL 'dev' argument.
104
+
*/
105
+
goto again;
94
106
}
95
107
}
96
108
spin_unlock_bh(&ax25_list_lock);
···
1121
1109
* some sanity checks. code further down depends on this
1122
1110
*/
1123
1111
1124
-
if (addr_len == sizeof(struct sockaddr_ax25)) {
1125
-
/* support for this will go away in early 2.5.x */
1126
-
printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n",
1127
-
current->comm);
1128
-
}
1129
-
else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1130
-
/* support for old structure may go away some time */
1112
+
if (addr_len == sizeof(struct sockaddr_ax25))
1113
+
/* support for this will go away in early 2.5.x
1114
+
* ax25_connect(): uses obsolete socket structure
1115
+
*/
1116
+
;
1117
+
else if (addr_len != sizeof(struct full_sockaddr_ax25))
1118
+
/* support for old structure may go away some time
1119
+
* ax25_connect(): uses old (6 digipeater) socket structure.
1120
+
*/
1131
1121
if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1132
-
(addr_len > sizeof(struct full_sockaddr_ax25))) {
1122
+
(addr_len > sizeof(struct full_sockaddr_ax25)))
1133
1123
return -EINVAL;
1134
-
}
1135
1124
1136
-
printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n",
1137
-
current->comm);
1138
-
}
1139
1125
1140
1126
if (fsa->fsa_ax25.sax25_family != AF_AX25)
1141
1127
return -EINVAL;
···
1477
1467
goto out;
1478
1468
}
1479
1469
1480
-
if (addr_len == sizeof(struct sockaddr_ax25)) {
1481
-
printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1482
-
current->comm);
1483
-
}
1484
-
else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1485
-
/* support for old structure may go away some time */
1470
+
if (addr_len == sizeof(struct sockaddr_ax25))
1471
+
/* ax25_sendmsg(): uses obsolete socket structure */
1472
+
;
1473
+
else if (addr_len != sizeof(struct full_sockaddr_ax25))
1474
+
/* support for old structure may go away some time
1475
+
* ax25_sendmsg(): uses old (6 digipeater)
1476
+
* socket structure.
1477
+
*/
1486
1478
if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1487
1479
(addr_len > sizeof(struct full_sockaddr_ax25))) {
1488
1480
err = -EINVAL;
1489
1481
goto out;
1490
1482
}
1491
1483
1492
-
printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1493
-
current->comm);
1494
-
}
1495
1484
1496
1485
if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1497
1486
int ct = 0;
+13
-9
net/bluetooth/rfcomm/tty.c
+13
-9
net/bluetooth/rfcomm/tty.c
···
95
95
96
96
BT_DBG("dev %p dlc %p", dev, dlc);
97
97
98
-
write_lock_bh(&rfcomm_dev_lock);
99
-
list_del_init(&dev->list);
100
-
write_unlock_bh(&rfcomm_dev_lock);
98
+
/* Refcount should only hit zero when called from rfcomm_dev_del()
99
+
which will have taken us off the list. Everything else are
100
+
refcounting bugs. */
101
+
BUG_ON(!list_empty(&dev->list));
101
102
102
103
rfcomm_dlc_lock(dlc);
103
104
/* Detach DLC if it's owned by this dev */
···
109
108
rfcomm_dlc_put(dlc);
110
109
111
110
tty_unregister_device(rfcomm_tty_driver, dev->id);
112
-
113
-
/* Refcount should only hit zero when called from rfcomm_dev_del()
114
-
which will have taken us off the list. Everything else are
115
-
refcounting bugs. */
116
-
BUG_ON(!list_empty(&dev->list));
117
111
118
112
kfree(dev);
119
113
···
309
313
{
310
314
BT_DBG("dev %p", dev);
311
315
312
-
set_bit(RFCOMM_TTY_RELEASED, &dev->flags);
316
+
if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
317
+
BUG_ON(1);
318
+
else
319
+
set_bit(RFCOMM_TTY_RELEASED, &dev->flags);
320
+
321
+
write_lock_bh(&rfcomm_dev_lock);
322
+
list_del_init(&dev->list);
323
+
write_unlock_bh(&rfcomm_dev_lock);
324
+
313
325
rfcomm_dev_put(dev);
314
326
}
315
327
+12
-6
net/bridge/br_netfilter.c
+12
-6
net/bridge/br_netfilter.c
···
247
247
* Let us first consider the case that ip_route_input() succeeds:
248
248
*
249
249
* If skb->dst->dev equals the logical bridge device the packet
250
-
* came in on, we can consider this bridging. We then call
251
-
* skb->dst->output() which will make the packet enter br_nf_local_out()
250
+
* came in on, we can consider this bridging. The packet is passed
251
+
* through the neighbour output function to build a new destination
252
+
* MAC address, which will make the packet enter br_nf_local_out()
252
253
* not much later. In that function it is assured that the iptables
253
254
* FORWARD chain is traversed for the packet.
254
255
*
···
286
285
skb->nf_bridge->mask ^= BRNF_NF_BRIDGE_PREROUTING;
287
286
288
287
skb->dev = bridge_parent(skb->dev);
289
-
if (!skb->dev)
290
-
kfree_skb(skb);
291
-
else {
288
+
if (skb->dev) {
289
+
struct dst_entry *dst = skb->dst;
290
+
292
291
nf_bridge_pull_encap_header(skb);
293
-
skb->dst->output(skb);
292
+
293
+
if (dst->hh)
294
+
return neigh_hh_output(dst->hh, skb);
295
+
else if (dst->neighbour)
296
+
return dst->neighbour->output(skb);
294
297
}
298
+
kfree_skb(skb);
295
299
return 0;
296
300
}
297
301
+2
-2
net/core/neighbour.c
+2
-2
net/core/neighbour.c
···
1316
1316
*p = parms->next;
1317
1317
parms->dead = 1;
1318
1318
write_unlock_bh(&tbl->lock);
1319
-
if (parms->dev)
1320
-
dev_put(parms->dev);
1321
1319
call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1322
1320
return;
1323
1321
}
···
1326
1328
1327
1329
void neigh_parms_destroy(struct neigh_parms *parms)
1328
1330
{
1331
+
if (parms->dev)
1332
+
dev_put(parms->dev);
1329
1333
kfree(parms);
1330
1334
}
1331
1335
+3
-3
net/decnet/dn_route.c
+3
-3
net/decnet/dn_route.c
···
1665
1665
break;
1666
1666
rcu_read_unlock_bh();
1667
1667
}
1668
-
return rt;
1668
+
return rcu_dereference(rt);
1669
1669
}
1670
1670
1671
1671
static struct dn_route *dn_rt_cache_get_next(struct seq_file *seq, struct dn_route *rt)
1672
1672
{
1673
-
struct dn_rt_cache_iter_state *s = rcu_dereference(seq->private);
1673
+
struct dn_rt_cache_iter_state *s = seq->private;
1674
1674
1675
1675
rt = rt->u.dst.dn_next;
1676
1676
while(!rt) {
···
1680
1680
rcu_read_lock_bh();
1681
1681
rt = dn_rt_hash_table[s->bucket].chain;
1682
1682
}
1683
-
return rt;
1683
+
return rcu_dereference(rt);
1684
1684
}
1685
1685
1686
1686
static void *dn_rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
+3
-3
net/ipv4/route.c
+3
-3
net/ipv4/route.c
···
283
283
break;
284
284
rcu_read_unlock_bh();
285
285
}
286
-
return r;
286
+
return rcu_dereference(r);
287
287
}
288
288
289
289
static struct rtable *rt_cache_get_next(struct seq_file *seq, struct rtable *r)
290
290
{
291
-
struct rt_cache_iter_state *st = rcu_dereference(seq->private);
291
+
struct rt_cache_iter_state *st = seq->private;
292
292
293
293
r = r->u.dst.rt_next;
294
294
while (!r) {
···
298
298
rcu_read_lock_bh();
299
299
r = rt_hash_table[st->bucket].chain;
300
300
}
301
-
return r;
301
+
return rcu_dereference(r);
302
302
}
303
303
304
304
static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
+1
-1
net/ipv6/netfilter/ip6t_eui64.c
+1
-1
net/ipv6/netfilter/ip6t_eui64.c
+2
-2
net/netfilter/xt_helper.c
+2
-2
net/netfilter/xt_helper.c