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) Fill in ethtool link parameters for all link types in cxgb4, from
Hariprasad Shenai.
2) Fix probe regressions in stmmac driver, from Huacai Chen.
3) Network namespace leaks on errirs in rtnetlink, from Nicolas
Dichtel.
4) Remove erroneous BUG check which can actually trigger legitimately,
in xen-netfront. From Seth Forshee.
5) Validate length of IFLA_BOND_ARP_IP_TARGET netlink attributes, from
Thomas Grag.
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net:
cxgb4: Fill in supported link mode for SFP modules
xen-netfront: Remove BUGs on paged skb data which crosses a page boundary
sh_eth: Fix sleeping function called from invalid context
stmmac: platform: Move plat_dat checking earlier
sh_eth: Fix skb alloc size and alignment adjust rule.
rtnetlink: release net refcnt on error in do_setlink()
bond: Check length of IFLA_BOND_ARP_IP_TARGET attributes
+73
-67
+6
-1
drivers/net/bonding/bond_netlink.c
+6
-1
drivers/net/bonding/bond_netlink.c
···
225
225
226
226
bond_option_arp_ip_targets_clear(bond);
227
227
nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
228
-
__be32 target = nla_get_be32(attr);
228
+
__be32 target;
229
+
230
+
if (nla_len(attr) < sizeof(target))
231
+
return -EINVAL;
232
+
233
+
target = nla_get_be32(attr);
229
234
230
235
bond_opt_initval(&newval, (__force u64)target);
231
236
err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
+6
-2
drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+6
-2
drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
···
2442
2442
SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full |
2443
2443
SUPPORTED_10000baseKX4_Full;
2444
2444
else if (type == FW_PORT_TYPE_FIBER_XFI ||
2445
-
type == FW_PORT_TYPE_FIBER_XAUI || type == FW_PORT_TYPE_SFP)
2445
+
type == FW_PORT_TYPE_FIBER_XAUI || type == FW_PORT_TYPE_SFP) {
2446
2446
v |= SUPPORTED_FIBRE;
2447
-
else if (type == FW_PORT_TYPE_BP40_BA)
2447
+
if (caps & FW_PORT_CAP_SPEED_1G)
2448
+
v |= SUPPORTED_1000baseT_Full;
2449
+
if (caps & FW_PORT_CAP_SPEED_10G)
2450
+
v |= SUPPORTED_10000baseT_Full;
2451
+
} else if (type == FW_PORT_TYPE_BP40_BA)
2448
2452
v |= SUPPORTED_40000baseSR4_Full;
2449
2453
2450
2454
if (caps & FW_PORT_CAP_ANEG)
+48
-48
drivers/net/ethernet/renesas/sh_eth.c
+48
-48
drivers/net/ethernet/renesas/sh_eth.c
···
917
917
return ret;
918
918
}
919
919
920
-
#if defined(CONFIG_CPU_SH4) || defined(CONFIG_ARCH_SHMOBILE)
921
920
static void sh_eth_set_receive_align(struct sk_buff *skb)
922
921
{
923
-
int reserve;
922
+
uintptr_t reserve = (uintptr_t)skb->data & (SH_ETH_RX_ALIGN - 1);
924
923
925
-
reserve = SH4_SKB_RX_ALIGN - ((u32)skb->data & (SH4_SKB_RX_ALIGN - 1));
926
924
if (reserve)
927
-
skb_reserve(skb, reserve);
925
+
skb_reserve(skb, SH_ETH_RX_ALIGN - reserve);
928
926
}
929
-
#else
930
-
static void sh_eth_set_receive_align(struct sk_buff *skb)
931
-
{
932
-
skb_reserve(skb, SH2_SH3_SKB_RX_ALIGN);
933
-
}
934
-
#endif
935
927
936
928
937
929
/* CPU <-> EDMAC endian convert */
···
1111
1119
struct sh_eth_txdesc *txdesc = NULL;
1112
1120
int rx_ringsize = sizeof(*rxdesc) * mdp->num_rx_ring;
1113
1121
int tx_ringsize = sizeof(*txdesc) * mdp->num_tx_ring;
1122
+
int skbuff_size = mdp->rx_buf_sz + SH_ETH_RX_ALIGN - 1;
1114
1123
1115
1124
mdp->cur_rx = 0;
1116
1125
mdp->cur_tx = 0;
···
1124
1131
for (i = 0; i < mdp->num_rx_ring; i++) {
1125
1132
/* skb */
1126
1133
mdp->rx_skbuff[i] = NULL;
1127
-
skb = netdev_alloc_skb(ndev, mdp->rx_buf_sz);
1134
+
skb = netdev_alloc_skb(ndev, skbuff_size);
1128
1135
mdp->rx_skbuff[i] = skb;
1129
1136
if (skb == NULL)
1130
1137
break;
1131
-
dma_map_single(&ndev->dev, skb->data, mdp->rx_buf_sz,
1132
-
DMA_FROM_DEVICE);
1133
1138
sh_eth_set_receive_align(skb);
1134
1139
1135
1140
/* RX descriptor */
1136
1141
rxdesc = &mdp->rx_ring[i];
1142
+
/* The size of the buffer is a multiple of 16 bytes. */
1143
+
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
1144
+
dma_map_single(&ndev->dev, skb->data, rxdesc->buffer_length,
1145
+
DMA_FROM_DEVICE);
1137
1146
rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
1138
1147
rxdesc->status = cpu_to_edmac(mdp, RD_RACT | RD_RFP);
1139
1148
1140
-
/* The size of the buffer is 16 byte boundary. */
1141
-
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
1142
1149
/* Rx descriptor address set */
1143
1150
if (i == 0) {
1144
1151
sh_eth_write(ndev, mdp->rx_desc_dma, RDLAR);
···
1390
1397
struct sk_buff *skb;
1391
1398
u16 pkt_len = 0;
1392
1399
u32 desc_status;
1400
+
int skbuff_size = mdp->rx_buf_sz + SH_ETH_RX_ALIGN - 1;
1393
1401
1394
1402
rxdesc = &mdp->rx_ring[entry];
1395
1403
while (!(rxdesc->status & cpu_to_edmac(mdp, RD_RACT))) {
···
1442
1448
if (mdp->cd->rpadir)
1443
1449
skb_reserve(skb, NET_IP_ALIGN);
1444
1450
dma_sync_single_for_cpu(&ndev->dev, rxdesc->addr,
1445
-
mdp->rx_buf_sz,
1451
+
ALIGN(mdp->rx_buf_sz, 16),
1446
1452
DMA_FROM_DEVICE);
1447
1453
skb_put(skb, pkt_len);
1448
1454
skb->protocol = eth_type_trans(skb, ndev);
···
1462
1468
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
1463
1469
1464
1470
if (mdp->rx_skbuff[entry] == NULL) {
1465
-
skb = netdev_alloc_skb(ndev, mdp->rx_buf_sz);
1471
+
skb = netdev_alloc_skb(ndev, skbuff_size);
1466
1472
mdp->rx_skbuff[entry] = skb;
1467
1473
if (skb == NULL)
1468
1474
break; /* Better luck next round. */
1469
-
dma_map_single(&ndev->dev, skb->data, mdp->rx_buf_sz,
1470
-
DMA_FROM_DEVICE);
1471
1475
sh_eth_set_receive_align(skb);
1476
+
dma_map_single(&ndev->dev, skb->data,
1477
+
rxdesc->buffer_length, DMA_FROM_DEVICE);
1472
1478
1473
1479
skb_checksum_none_assert(skb);
1474
1480
rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
···
2036
2042
if (ret)
2037
2043
goto out_free_irq;
2038
2044
2045
+
mdp->is_opened = 1;
2046
+
2039
2047
return ret;
2040
2048
2041
2049
out_free_irq:
···
2127
2131
return NETDEV_TX_OK;
2128
2132
}
2129
2133
2134
+
static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
2135
+
{
2136
+
struct sh_eth_private *mdp = netdev_priv(ndev);
2137
+
2138
+
if (sh_eth_is_rz_fast_ether(mdp))
2139
+
return &ndev->stats;
2140
+
2141
+
if (!mdp->is_opened)
2142
+
return &ndev->stats;
2143
+
2144
+
ndev->stats.tx_dropped += sh_eth_read(ndev, TROCR);
2145
+
sh_eth_write(ndev, 0, TROCR); /* (write clear) */
2146
+
ndev->stats.collisions += sh_eth_read(ndev, CDCR);
2147
+
sh_eth_write(ndev, 0, CDCR); /* (write clear) */
2148
+
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, LCCR);
2149
+
sh_eth_write(ndev, 0, LCCR); /* (write clear) */
2150
+
2151
+
if (sh_eth_is_gether(mdp)) {
2152
+
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CERCR);
2153
+
sh_eth_write(ndev, 0, CERCR); /* (write clear) */
2154
+
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CEECR);
2155
+
sh_eth_write(ndev, 0, CEECR); /* (write clear) */
2156
+
} else {
2157
+
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CNDCR);
2158
+
sh_eth_write(ndev, 0, CNDCR); /* (write clear) */
2159
+
}
2160
+
2161
+
return &ndev->stats;
2162
+
}
2163
+
2130
2164
/* device close function */
2131
2165
static int sh_eth_close(struct net_device *ndev)
2132
2166
{
···
2171
2145
sh_eth_write(ndev, 0, EDTRR);
2172
2146
sh_eth_write(ndev, 0, EDRRR);
2173
2147
2148
+
sh_eth_get_stats(ndev);
2174
2149
/* PHY Disconnect */
2175
2150
if (mdp->phydev) {
2176
2151
phy_stop(mdp->phydev);
···
2190
2163
2191
2164
pm_runtime_put_sync(&mdp->pdev->dev);
2192
2165
2166
+
mdp->is_opened = 0;
2167
+
2193
2168
return 0;
2194
-
}
2195
-
2196
-
static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
2197
-
{
2198
-
struct sh_eth_private *mdp = netdev_priv(ndev);
2199
-
2200
-
if (sh_eth_is_rz_fast_ether(mdp))
2201
-
return &ndev->stats;
2202
-
2203
-
pm_runtime_get_sync(&mdp->pdev->dev);
2204
-
2205
-
ndev->stats.tx_dropped += sh_eth_read(ndev, TROCR);
2206
-
sh_eth_write(ndev, 0, TROCR); /* (write clear) */
2207
-
ndev->stats.collisions += sh_eth_read(ndev, CDCR);
2208
-
sh_eth_write(ndev, 0, CDCR); /* (write clear) */
2209
-
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, LCCR);
2210
-
sh_eth_write(ndev, 0, LCCR); /* (write clear) */
2211
-
if (sh_eth_is_gether(mdp)) {
2212
-
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CERCR);
2213
-
sh_eth_write(ndev, 0, CERCR); /* (write clear) */
2214
-
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CEECR);
2215
-
sh_eth_write(ndev, 0, CEECR); /* (write clear) */
2216
-
} else {
2217
-
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CNDCR);
2218
-
sh_eth_write(ndev, 0, CNDCR); /* (write clear) */
2219
-
}
2220
-
pm_runtime_put_sync(&mdp->pdev->dev);
2221
-
2222
-
return &ndev->stats;
2223
2169
}
2224
2170
2225
2171
/* ioctl to device function */
+3
-2
drivers/net/ethernet/renesas/sh_eth.h
+3
-2
drivers/net/ethernet/renesas/sh_eth.h
···
162
162
163
163
/* Driver's parameters */
164
164
#if defined(CONFIG_CPU_SH4) || defined(CONFIG_ARCH_SHMOBILE)
165
-
#define SH4_SKB_RX_ALIGN 32
165
+
#define SH_ETH_RX_ALIGN 32
166
166
#else
167
-
#define SH2_SH3_SKB_RX_ALIGN 2
167
+
#define SH_ETH_RX_ALIGN 2
168
168
#endif
169
169
170
170
/* Register's bits
···
522
522
523
523
unsigned no_ether_link:1;
524
524
unsigned ether_link_active_low:1;
525
+
unsigned is_opened:1;
525
526
};
526
527
527
528
static inline void sh_eth_soft_swap(char *src, int len)
+9
-9
drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+9
-9
drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
···
265
265
266
266
plat_dat = dev_get_platdata(&pdev->dev);
267
267
268
+
if (!plat_dat)
269
+
plat_dat = devm_kzalloc(&pdev->dev,
270
+
sizeof(struct plat_stmmacenet_data),
271
+
GFP_KERNEL);
272
+
if (!plat_dat) {
273
+
pr_err("%s: ERROR: no memory", __func__);
274
+
return -ENOMEM;
275
+
}
276
+
268
277
/* Set default value for multicast hash bins */
269
278
plat_dat->multicast_filter_bins = HASH_TABLE_SIZE;
270
279
···
281
272
plat_dat->unicast_filter_entries = 1;
282
273
283
274
if (pdev->dev.of_node) {
284
-
if (!plat_dat)
285
-
plat_dat = devm_kzalloc(&pdev->dev,
286
-
sizeof(struct plat_stmmacenet_data),
287
-
GFP_KERNEL);
288
-
if (!plat_dat) {
289
-
pr_err("%s: ERROR: no memory", __func__);
290
-
return -ENOMEM;
291
-
}
292
-
293
275
ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
294
276
if (ret) {
295
277
pr_err("%s: main dt probe failed", __func__);
-5
drivers/net/xen-netfront.c
-5
drivers/net/xen-netfront.c
···
496
496
len = skb_frag_size(frag);
497
497
offset = frag->page_offset;
498
498
499
-
/* Data must not cross a page boundary. */
500
-
BUG_ON(len + offset > PAGE_SIZE<<compound_order(page));
501
-
502
499
/* Skip unused frames from start of page */
503
500
page += offset >> PAGE_SHIFT;
504
501
offset &= ~PAGE_MASK;
505
502
506
503
while (len > 0) {
507
504
unsigned long bytes;
508
-
509
-
BUG_ON(offset >= PAGE_SIZE);
510
505
511
506
bytes = PAGE_SIZE - offset;
512
507
if (bytes > len)