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
Pull networking fixes from David Miller:
1) Make fragmentation IDs less predictable, from Eric Dumazet.
2) TSO tunneling can crash in bnx2x driver, fix from Dmitry Kravkov.
3) Don't allow NULL msg->msg_name just because msg->msg_namelen is
non-zero, from Andrey Ryabinin.
4) ndm->ndm_type set using wrong macros, from Jun Zhao.
5) cdc-ether devices can come up with entries in their address filter,
so explicitly clear the filter after the device initializes. From
Oliver Neukum.
6) Forgotten refcount bump in xfrm_lookup(), from Steffen Klassert.
7) Short packets not padded properly, exposing random data, in bcmgenet
driver. Fix from Florian Fainelli.
8) xgbe_probe() doesn't return an error code, but rather zero, when
netif_set_real_num_tx_queues() fails. Fix from Wei Yongjun.
9) USB speed not probed properly in r8152 driver, from Hayes Wang.
10) Transmit logic choosing the outgoing port in the sunvnet driver
needs to consider a) is the port actually up and b) whether it is a
switch port. Fix from David L Stevens.
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (27 commits)
net: phy: re-apply PHY fixups during phy_register_device
cdc-ether: clean packet filter upon probe
cdc_subset: deal with a device that needs reset for timeout
net: sendmsg: fix NULL pointer dereference
isdn/bas_gigaset: fix a leak on failure path in gigaset_probe()
ip: make IP identifiers less predictable
neighbour : fix ndm_type type error issue
sunvnet: only use connected ports when sending
can: c_can_platform: Fix raminit, use devm_ioremap() instead of devm_ioremap_resource()
bnx2x: fix crash during TSO tunneling
r8152: fix the checking of the usb speed
net: phy: Ensure the MDIO bus module is held
net: phy: Set the driver when registering an MDIO bus device
bnx2x: fix set_setting for some PHYs
hyperv: Fix error return code in netvsc_init_buf()
amd-xgbe: Fix error return code in xgbe_probe()
ath9k: fix aggregation session lockup
net: bcmgenet: correctly pad short packets
net: sctp: inherit auth_capable on INIT collisions
mac80211: fix crash on getting sta info with uninitialized rate control
...
+197
-63
+1
drivers/isdn/gigaset/bas-gigaset.c
+1
drivers/isdn/gigaset/bas-gigaset.c
+2
-1
drivers/net/can/c_can/c_can_platform.c
+2
-1
drivers/net/can/c_can/c_can_platform.c
···
287
287
break;
288
288
}
289
289
290
-
priv->raminit_ctrlreg = devm_ioremap_resource(&pdev->dev, res);
290
+
priv->raminit_ctrlreg = devm_ioremap(&pdev->dev, res->start,
291
+
resource_size(res));
291
292
if (IS_ERR(priv->raminit_ctrlreg) || priv->instance < 0)
292
293
dev_info(&pdev->dev, "control memory is not used for raminit\n");
293
294
else
+2
-1
drivers/net/ethernet/amd/xgbe/xgbe-main.c
+2
-1
drivers/net/ethernet/amd/xgbe/xgbe-main.c
···
339
339
/* Calculate the number of Tx and Rx rings to be created */
340
340
pdata->tx_ring_count = min_t(unsigned int, num_online_cpus(),
341
341
pdata->hw_feat.tx_ch_cnt);
342
-
if (netif_set_real_num_tx_queues(netdev, pdata->tx_ring_count)) {
342
+
ret = netif_set_real_num_tx_queues(netdev, pdata->tx_ring_count);
343
+
if (ret) {
343
344
dev_err(dev, "error setting real tx queue count\n");
344
345
goto err_io;
345
346
}
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+9
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+9
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
···
227
227
--nbd;
228
228
bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
229
229
230
+
if (tx_buf->flags & BNX2X_HAS_SECOND_PBD) {
231
+
/* Skip second parse bd... */
232
+
--nbd;
233
+
bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
234
+
}
235
+
230
236
/* TSO headers+data bds share a common mapping. See bnx2x_tx_split() */
231
237
if (tx_buf->flags & BNX2X_TSO_SPLIT_BD) {
232
238
tx_data_bd = &txdata->tx_desc_ring[bd_idx].reg_bd;
···
3895
3889
/* set encapsulation flag in start BD */
3896
3890
SET_FLAG(tx_start_bd->general_data,
3897
3891
ETH_TX_START_BD_TUNNEL_EXIST, 1);
3892
+
3893
+
tx_buf->flags |= BNX2X_HAS_SECOND_PBD;
3894
+
3898
3895
nbd++;
3899
3896
} else if (xmit_type & XMIT_CSUM) {
3900
3897
/* Set PBD in checksum offload case w/o encapsulation */
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
+5
drivers/net/ethernet/broadcom/genet/bcmgenet.c
+5
drivers/net/ethernet/broadcom/genet/bcmgenet.c
+17
-5
drivers/net/ethernet/sun/sunvnet.c
+17
-5
drivers/net/ethernet/sun/sunvnet.c
···
610
610
return err;
611
611
}
612
612
613
+
static inline bool port_is_up(struct vnet_port *vnet)
614
+
{
615
+
struct vio_driver_state *vio = &vnet->vio;
616
+
617
+
return !!(vio->hs_state & VIO_HS_COMPLETE);
618
+
}
619
+
613
620
struct vnet_port *__tx_port_find(struct vnet *vp, struct sk_buff *skb)
614
621
{
615
622
unsigned int hash = vnet_hashfn(skb->data);
···
624
617
struct vnet_port *port;
625
618
626
619
hlist_for_each_entry(port, hp, hash) {
620
+
if (!port_is_up(port))
621
+
continue;
627
622
if (ether_addr_equal(port->raddr, skb->data))
628
623
return port;
629
624
}
630
-
port = NULL;
631
-
if (!list_empty(&vp->port_list))
632
-
port = list_entry(vp->port_list.next, struct vnet_port, list);
633
-
634
-
return port;
625
+
list_for_each_entry(port, &vp->port_list, list) {
626
+
if (!port->switch_port)
627
+
continue;
628
+
if (!port_is_up(port))
629
+
continue;
630
+
return port;
631
+
}
632
+
return NULL;
635
633
}
636
634
637
635
struct vnet_port *tx_port_find(struct vnet *vp, struct sk_buff *skb)
+3
-1
drivers/net/hyperv/netvsc.c
+3
-1
drivers/net/hyperv/netvsc.c
···
378
378
379
379
net_device->send_section_map =
380
380
kzalloc(net_device->map_words * sizeof(ulong), GFP_KERNEL);
381
-
if (net_device->send_section_map == NULL)
381
+
if (net_device->send_section_map == NULL) {
382
+
ret = -ENOMEM;
382
383
goto cleanup;
384
+
}
383
385
384
386
goto exit;
385
387
+1
drivers/net/phy/mdio_bus.c
+1
drivers/net/phy/mdio_bus.c
+14
-1
drivers/net/phy/phy_device.c
+14
-1
drivers/net/phy/phy_device.c
···
355
355
phydev->bus->phy_map[phydev->addr] = phydev;
356
356
357
357
/* Run all of the fixups for this PHY */
358
-
err = phy_init_hw(phydev);
358
+
err = phy_scan_fixups(phydev);
359
359
if (err) {
360
360
pr_err("PHY %d failed to initialize\n", phydev->addr);
361
361
goto out;
···
575
575
u32 flags, phy_interface_t interface)
576
576
{
577
577
struct device *d = &phydev->dev;
578
+
struct module *bus_module;
578
579
int err;
579
580
580
581
/* Assume that if there is no driver, that it doesn't
···
598
597
if (phydev->attached_dev) {
599
598
dev_err(&dev->dev, "PHY already attached\n");
600
599
return -EBUSY;
600
+
}
601
+
602
+
/* Increment the bus module reference count */
603
+
bus_module = phydev->bus->dev.driver ?
604
+
phydev->bus->dev.driver->owner : NULL;
605
+
if (!try_module_get(bus_module)) {
606
+
dev_err(&dev->dev, "failed to get the bus module\n");
607
+
return -EIO;
601
608
}
602
609
603
610
phydev->attached_dev = dev;
···
673
664
void phy_detach(struct phy_device *phydev)
674
665
{
675
666
int i;
667
+
668
+
if (phydev->bus->dev.driver)
669
+
module_put(phydev->bus->dev.driver->owner);
670
+
676
671
phydev->attached_dev->phydev = NULL;
677
672
phydev->attached_dev = NULL;
678
673
phy_suspend(phydev);
+16
drivers/net/usb/cdc_ether.c
+16
drivers/net/usb/cdc_ether.c
···
341
341
usb_driver_release_interface(driver, info->data);
342
342
return -ENODEV;
343
343
}
344
+
345
+
/* Some devices don't initialise properly. In particular
346
+
* the packet filter is not reset. There are devices that
347
+
* don't do reset all the way. So the packet filter should
348
+
* be set to a sane initial value.
349
+
*/
350
+
usb_control_msg(dev->udev,
351
+
usb_sndctrlpipe(dev->udev, 0),
352
+
USB_CDC_SET_ETHERNET_PACKET_FILTER,
353
+
USB_TYPE_CLASS | USB_RECIP_INTERFACE,
354
+
USB_CDC_PACKET_TYPE_ALL_MULTICAST | USB_CDC_PACKET_TYPE_DIRECTED | USB_CDC_PACKET_TYPE_BROADCAST,
355
+
intf->cur_altsetting->desc.bInterfaceNumber,
356
+
NULL,
357
+
0,
358
+
USB_CTRL_SET_TIMEOUT
359
+
);
344
360
return 0;
345
361
346
362
bad_desc:
+27
drivers/net/usb/cdc_subset.c
+27
drivers/net/usb/cdc_subset.c
···
85
85
*
86
86
*-------------------------------------------------------------------------*/
87
87
88
+
static void m5632_recover(struct usbnet *dev)
89
+
{
90
+
struct usb_device *udev = dev->udev;
91
+
struct usb_interface *intf = dev->intf;
92
+
int r;
93
+
94
+
r = usb_lock_device_for_reset(udev, intf);
95
+
if (r < 0)
96
+
return;
97
+
98
+
usb_reset_device(udev);
99
+
usb_unlock_device(udev);
100
+
}
101
+
102
+
static int dummy_prereset(struct usb_interface *intf)
103
+
{
104
+
return 0;
105
+
}
106
+
107
+
static int dummy_postreset(struct usb_interface *intf)
108
+
{
109
+
return 0;
110
+
}
111
+
88
112
static const struct driver_info ali_m5632_info = {
89
113
.description = "ALi M5632",
90
114
.flags = FLAG_POINTTOPOINT,
115
+
.recover = m5632_recover,
91
116
};
92
117
93
118
#endif
···
357
332
.probe = usbnet_probe,
358
333
.suspend = usbnet_suspend,
359
334
.resume = usbnet_resume,
335
+
.pre_reset = dummy_prereset,
336
+
.post_reset = dummy_postreset,
360
337
.disconnect = usbnet_disconnect,
361
338
.id_table = products,
362
339
.disable_hub_initiated_lpm = 1,
+3
-4
drivers/net/usb/r8152.c
+3
-4
drivers/net/usb/r8152.c
···
282
282
/* USB_DEV_STAT */
283
283
#define STAT_SPEED_MASK 0x0006
284
284
#define STAT_SPEED_HIGH 0x0000
285
-
#define STAT_SPEED_FULL 0x0001
285
+
#define STAT_SPEED_FULL 0x0002
286
286
287
287
/* USB_TX_AGG */
288
288
#define TX_AGG_MAX_THRESHOLD 0x03
···
2292
2292
/* rx share fifo credit full threshold */
2293
2293
ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);
2294
2294
2295
-
ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_DEV_STAT);
2296
-
ocp_data &= STAT_SPEED_MASK;
2297
-
if (ocp_data == STAT_SPEED_FULL) {
2295
+
if (tp->udev->speed == USB_SPEED_FULL ||
2296
+
tp->udev->speed == USB_SPEED_LOW) {
2298
2297
/* rx share fifo credit near full threshold */
2299
2298
ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
2300
2299
RXFIFO_THR2_FULL);
+6
-2
drivers/net/usb/usbnet.c
+6
-2
drivers/net/usb/usbnet.c
···
1218
1218
1219
1219
unlink_urbs (dev, &dev->txq);
1220
1220
tasklet_schedule (&dev->bh);
1221
-
1222
-
// FIXME: device recovery -- reset?
1221
+
/* this needs to be handled individually because the generic layer
1222
+
* doesn't know what is sufficient and could not restore private
1223
+
* information if a remedy of an unconditional reset were used.
1224
+
*/
1225
+
if (dev->driver_info->recover)
1226
+
(dev->driver_info->recover)(dev);
1223
1227
}
1224
1228
EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
1225
1229
+1
-1
drivers/net/vxlan.c
+1
-1
drivers/net/vxlan.c
···
339
339
ndm->ndm_state = fdb->state;
340
340
ndm->ndm_ifindex = vxlan->dev->ifindex;
341
341
ndm->ndm_flags = fdb->flags;
342
-
ndm->ndm_type = NDA_DST;
342
+
ndm->ndm_type = RTN_UNICAST;
343
343
344
344
if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
345
345
goto nla_put_failure;
+9
drivers/net/wireless/ath/ath9k/xmit.c
+9
drivers/net/wireless/ath/ath9k/xmit.c
···
887
887
888
888
tx_info = IEEE80211_SKB_CB(skb);
889
889
tx_info->flags &= ~IEEE80211_TX_CTL_CLEAR_PS_FILT;
890
+
891
+
/*
892
+
* No aggregation session is running, but there may be frames
893
+
* from a previous session or a failed attempt in the queue.
894
+
* Send them out as normal data frames
895
+
*/
896
+
if (!tid->active)
897
+
tx_info->flags &= ~IEEE80211_TX_CTL_AMPDU;
898
+
890
899
if (!(tx_info->flags & IEEE80211_TX_CTL_AMPDU)) {
891
900
bf->bf_state.bf_type = 0;
892
901
return bf;
+13
-2
drivers/net/wireless/iwlwifi/mvm/mac-ctxt.c
+13
-2
drivers/net/wireless/iwlwifi/mvm/mac-ctxt.c
···
1072
1072
/* Fill the common data for all mac context types */
1073
1073
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
1074
1074
1075
-
/* Also enable probe requests to pass */
1076
-
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST);
1075
+
/*
1076
+
* pass probe requests and beacons from other APs (needed
1077
+
* for ht protection)
1078
+
*/
1079
+
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST |
1080
+
MAC_FILTER_IN_BEACON);
1077
1081
1078
1082
/* Fill the data specific for ap mode */
1079
1083
iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd.ap,
···
1097
1093
1098
1094
/* Fill the common data for all mac context types */
1099
1095
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, action);
1096
+
1097
+
/*
1098
+
* pass probe requests and beacons from other APs (needed
1099
+
* for ht protection)
1100
+
*/
1101
+
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST |
1102
+
MAC_FILTER_IN_BEACON);
1100
1103
1101
1104
/* Fill the data specific for GO mode */
1102
1105
iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd.go.ap,
-7
drivers/net/wireless/iwlwifi/mvm/mac80211.c
-7
drivers/net/wireless/iwlwifi/mvm/mac80211.c
···
303
303
hw->uapsd_max_sp_len = IWL_UAPSD_MAX_SP;
304
304
}
305
305
306
-
if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT &&
307
-
!iwlwifi_mod_params.uapsd_disable) {
308
-
hw->flags |= IEEE80211_HW_SUPPORTS_UAPSD;
309
-
hw->uapsd_queues = IWL_UAPSD_AC_INFO;
310
-
hw->uapsd_max_sp_len = IWL_UAPSD_MAX_SP;
311
-
}
312
-
313
306
hw->sta_data_size = sizeof(struct iwl_mvm_sta);
314
307
hw->vif_data_size = sizeof(struct iwl_mvm_vif);
315
308
hw->chanctx_data_size = sizeof(u16);
+3
include/linux/usb/usbnet.h
+3
include/linux/usb/usbnet.h
···
148
148
struct sk_buff *(*tx_fixup)(struct usbnet *dev,
149
149
struct sk_buff *skb, gfp_t flags);
150
150
151
+
/* recover from timeout */
152
+
void (*recover)(struct usbnet *dev);
153
+
151
154
/* early initialization code, can sleep. This is for minidrivers
152
155
* having 'subminidrivers' that need to do extra initialization
153
156
* right after minidriver have initialized hardware. */
+1
-10
include/net/ip.h
+1
-10
include/net/ip.h
···
309
309
}
310
310
}
311
311
312
-
#define IP_IDENTS_SZ 2048u
313
-
extern atomic_t *ip_idents;
314
-
315
-
static inline u32 ip_idents_reserve(u32 hash, int segs)
316
-
{
317
-
atomic_t *id_ptr = ip_idents + hash % IP_IDENTS_SZ;
318
-
319
-
return atomic_add_return(segs, id_ptr) - segs;
320
-
}
321
-
312
+
u32 ip_idents_reserve(u32 hash, int segs);
322
313
void __ip_select_ident(struct iphdr *iph, int segs);
323
314
324
315
static inline void ip_select_ident_segs(struct sk_buff *skb, struct sock *sk, int segs)
+5
-4
net/compat.c
+5
-4
net/compat.c
···
85
85
{
86
86
int tot_len;
87
87
88
-
if (kern_msg->msg_namelen) {
88
+
if (kern_msg->msg_name && kern_msg->msg_namelen) {
89
89
if (mode == VERIFY_READ) {
90
90
int err = move_addr_to_kernel(kern_msg->msg_name,
91
91
kern_msg->msg_namelen,
···
93
93
if (err < 0)
94
94
return err;
95
95
}
96
-
if (kern_msg->msg_name)
97
-
kern_msg->msg_name = kern_address;
98
-
} else
96
+
kern_msg->msg_name = kern_address;
97
+
} else {
99
98
kern_msg->msg_name = NULL;
99
+
kern_msg->msg_namelen = 0;
100
+
}
100
101
101
102
tot_len = iov_from_user_compat_to_kern(kern_iov,
102
103
(struct compat_iovec __user *)kern_msg->msg_iov,
+3
-3
net/core/iovec.c
+3
-3
net/core/iovec.c
···
39
39
{
40
40
int size, ct, err;
41
41
42
-
if (m->msg_namelen) {
42
+
if (m->msg_name && m->msg_namelen) {
43
43
if (mode == VERIFY_READ) {
44
44
void __user *namep;
45
45
namep = (void __user __force *) m->msg_name;
···
48
48
if (err < 0)
49
49
return err;
50
50
}
51
-
if (m->msg_name)
52
-
m->msg_name = address;
51
+
m->msg_name = address;
53
52
} else {
54
53
m->msg_name = NULL;
54
+
m->msg_namelen = 0;
55
55
}
56
56
57
57
size = m->msg_iovlen * sizeof(struct iovec);
+1
-1
net/core/neighbour.c
+1
-1
net/core/neighbour.c
+29
-3
net/ipv4/route.c
+29
-3
net/ipv4/route.c
···
457
457
return neigh_create(&arp_tbl, pkey, dev);
458
458
}
459
459
460
-
atomic_t *ip_idents __read_mostly;
461
-
EXPORT_SYMBOL(ip_idents);
460
+
#define IP_IDENTS_SZ 2048u
461
+
struct ip_ident_bucket {
462
+
atomic_t id;
463
+
u32 stamp32;
464
+
};
465
+
466
+
static struct ip_ident_bucket *ip_idents __read_mostly;
467
+
468
+
/* In order to protect privacy, we add a perturbation to identifiers
469
+
* if one generator is seldom used. This makes hard for an attacker
470
+
* to infer how many packets were sent between two points in time.
471
+
*/
472
+
u32 ip_idents_reserve(u32 hash, int segs)
473
+
{
474
+
struct ip_ident_bucket *bucket = ip_idents + hash % IP_IDENTS_SZ;
475
+
u32 old = ACCESS_ONCE(bucket->stamp32);
476
+
u32 now = (u32)jiffies;
477
+
u32 delta = 0;
478
+
479
+
if (old != now && cmpxchg(&bucket->stamp32, old, now) == old)
480
+
delta = prandom_u32_max(now - old);
481
+
482
+
return atomic_add_return(segs + delta, &bucket->id) - segs;
483
+
}
484
+
EXPORT_SYMBOL(ip_idents_reserve);
462
485
463
486
void __ip_select_ident(struct iphdr *iph, int segs)
464
487
{
···
490
467
491
468
net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
492
469
493
-
hash = jhash_1word((__force u32)iph->daddr, ip_idents_hashrnd);
470
+
hash = jhash_3words((__force u32)iph->daddr,
471
+
(__force u32)iph->saddr,
472
+
iph->protocol,
473
+
ip_idents_hashrnd);
494
474
id = ip_idents_reserve(hash, segs);
495
475
iph->id = htons(id);
496
476
}
+2
net/ipv6/ip6_output.c
+2
net/ipv6/ip6_output.c
···
545
545
net_get_random_once(&ip6_idents_hashrnd, sizeof(ip6_idents_hashrnd));
546
546
547
547
hash = __ipv6_addr_jhash(&rt->rt6i_dst.addr, ip6_idents_hashrnd);
548
+
hash = __ipv6_addr_jhash(&rt->rt6i_src.addr, hash);
549
+
548
550
id = ip_idents_reserve(hash, 1);
549
551
fhdr->identification = htonl(id);
550
552
}
+4
-1
net/mac80211/cfg.c
+4
-1
net/mac80211/cfg.c
···
472
472
{
473
473
struct ieee80211_sub_if_data *sdata = sta->sdata;
474
474
struct ieee80211_local *local = sdata->local;
475
-
struct rate_control_ref *ref = local->rate_ctrl;
475
+
struct rate_control_ref *ref = NULL;
476
476
struct timespec uptime;
477
477
u64 packets = 0;
478
478
u32 thr = 0;
479
479
int i, ac;
480
+
481
+
if (test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
482
+
ref = local->rate_ctrl;
480
483
481
484
sinfo->generation = sdata->local->sta_generation;
482
485
+10
-10
net/mac80211/tx.c
+10
-10
net/mac80211/tx.c
···
414
414
if (ieee80211_has_order(hdr->frame_control))
415
415
return TX_CONTINUE;
416
416
417
+
if (ieee80211_is_probe_req(hdr->frame_control))
418
+
return TX_CONTINUE;
419
+
417
420
if (tx->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
418
421
info->hw_queue = tx->sdata->vif.cab_queue;
419
422
···
466
463
{
467
464
struct sta_info *sta = tx->sta;
468
465
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
466
+
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
469
467
struct ieee80211_local *local = tx->local;
470
468
471
469
if (unlikely(!sta))
···
476
472
test_sta_flag(sta, WLAN_STA_PS_DRIVER)) &&
477
473
!(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER))) {
478
474
int ac = skb_get_queue_mapping(tx->skb);
475
+
476
+
if (ieee80211_is_mgmt(hdr->frame_control) &&
477
+
!ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
478
+
info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
479
+
return TX_CONTINUE;
480
+
}
479
481
480
482
ps_dbg(sta->sdata, "STA %pM aid %d: PS buffer for AC %d\n",
481
483
sta->sta.addr, sta->sta.aid, ac);
···
541
531
static ieee80211_tx_result debug_noinline
542
532
ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
543
533
{
544
-
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
545
-
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
546
-
547
534
if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
548
535
return TX_CONTINUE;
549
-
550
-
if (ieee80211_is_mgmt(hdr->frame_control) &&
551
-
!ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
552
-
if (tx->flags & IEEE80211_TX_UNICAST)
553
-
info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
554
-
return TX_CONTINUE;
555
-
}
556
536
557
537
if (tx->flags & IEEE80211_TX_UNICAST)
558
538
return ieee80211_tx_h_unicast_ps_buf(tx);
-1
net/netfilter/ipvs/ip_vs_conn.c
-1
net/netfilter/ipvs/ip_vs_conn.c
+1
net/sctp/associola.c
+1
net/sctp/associola.c
···
1097
1097
asoc->c = new->c;
1098
1098
asoc->peer.rwnd = new->peer.rwnd;
1099
1099
asoc->peer.sack_needed = new->peer.sack_needed;
1100
+
asoc->peer.auth_capable = new->peer.auth_capable;
1100
1101
asoc->peer.i = new->peer.i;
1101
1102
sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
1102
1103
asoc->peer.i.initial_tsn, GFP_ATOMIC);
+2
-1
net/wireless/trace.h
+2
-1
net/wireless/trace.h
···
2094
2094
MAC_ASSIGN(addr, addr);
2095
2095
__entry->key_type = key_type;
2096
2096
__entry->key_id = key_id;
2097
-
memcpy(__entry->tsc, tsc, 6);
2097
+
if (tsc)
2098
+
memcpy(__entry->tsc, tsc, 6);
2098
2099
),
2099
2100
TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm",
2100
2101
NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type,
+2
net/xfrm/xfrm_policy.c
+2
net/xfrm/xfrm_policy.c
+3
-4
net/xfrm/xfrm_user.c
+3
-4
net/xfrm/xfrm_user.c
···
177
177
attrs[XFRMA_ALG_AEAD] ||
178
178
attrs[XFRMA_ALG_CRYPT] ||
179
179
attrs[XFRMA_ALG_COMP] ||
180
-
attrs[XFRMA_TFCPAD] ||
181
-
(ntohl(p->id.spi) >= 0x10000))
182
-
180
+
attrs[XFRMA_TFCPAD])
183
181
goto out;
184
182
break;
185
183
···
205
207
attrs[XFRMA_ALG_AUTH] ||
206
208
attrs[XFRMA_ALG_AUTH_TRUNC] ||
207
209
attrs[XFRMA_ALG_CRYPT] ||
208
-
attrs[XFRMA_TFCPAD])
210
+
attrs[XFRMA_TFCPAD] ||
211
+
(ntohl(p->id.spi) >= 0x10000))
209
212
goto out;
210
213
break;
211
214