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) Off by one in netlink parsing of mac802154_hwsim, from Alexander
Aring.
2) nf_tables RCU usage fix from Taehee Yoo.
3) Flow dissector needs nhoff and thoff clamping, from Stanislav
Fomichev.
4) Missing sin6_flowinfo initialization in SCTP, from Xin Long.
5) Spectrev1 in ipmr and ip6mr, from Gustavo A. R. Silva.
6) Fix r8169 crash when DEBUG_SHIRQ is enabled, from Heiner Kallweit.
7) Fix SKB leak in rtlwifi, from Larry Finger.
8) Fix state pruning in bpf verifier, from Jakub Kicinski.
9) Don't handle completely duplicate fragments as overlapping, from
Michal Kubecek.
10) Fix memory corruption with macb and 64-bit DMA, from Anssi Hannula.
11) Fix TCP fallback socket release in smc, from Myungho Jung.
12) gro_cells_destroy needs to napi_disable, from Lorenzo Bianconi.
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (130 commits)
rds: Fix warning.
neighbor: NTF_PROXY is a valid ndm_flag for a dump request
net: mvpp2: fix the phylink mode validation
net/sched: cls_flower: Remove old entries from rhashtable
net/tls: allocate tls context using GFP_ATOMIC
iptunnel: make TUNNEL_FLAGS available in uapi
gro_cell: add napi_disable in gro_cells_destroy
lan743x: Remove MAC Reset from initialization
net/mlx5e: Remove the false indication of software timestamping support
net/mlx5: Typo fix in del_sw_hw_rule
net/mlx5e: RX, Fix wrong early return in receive queue poll
ipv6: explicitly initialize udp6_addr in udp_sock_create6()
bnxt_en: Fix ethtool self-test loopback.
net/rds: remove user triggered WARN_ON in rds_sendmsg
net/rds: fix warn in rds_message_alloc_sgs
ath10k: skip sending quiet mode cmd for WCN3990
mac80211: free skb fraglist before freeing the skb
nl80211: fix memory leak if validate_pae_over_nl80211() fails
net/smc: fix TCP fallback socket release
vxge: ensure data0 is initialized in when fetching firmware version information
...
+1577
-771
+9
-2
MAINTAINERS
+9
-2
MAINTAINERS
···
8943
8943
8944
8944
MARVELL 88E6XXX ETHERNET SWITCH FABRIC DRIVER
8945
8945
M: Andrew Lunn <andrew@lunn.ch>
8946
-
M: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
8946
+
M: Vivien Didelot <vivien.didelot@gmail.com>
8947
8947
L: netdev@vger.kernel.org
8948
8948
S: Maintained
8949
8949
F: drivers/net/dsa/mv88e6xxx/
···
9447
9447
F: drivers/media/platform/mtk-vpu/
9448
9448
F: Documentation/devicetree/bindings/media/mediatek-vcodec.txt
9449
9449
F: Documentation/devicetree/bindings/media/mediatek-vpu.txt
9450
+
9451
+
MEDIATEK MT76 WIRELESS LAN DRIVER
9452
+
M: Felix Fietkau <nbd@nbd.name>
9453
+
M: Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
9454
+
L: linux-wireless@vger.kernel.org
9455
+
S: Maintained
9456
+
F: drivers/net/wireless/mediatek/mt76/
9450
9457
9451
9458
MEDIATEK MT7601U WIRELESS LAN DRIVER
9452
9459
M: Jakub Kicinski <kubakici@wp.pl>
···
10425
10418
10426
10419
NETWORKING [DSA]
10427
10420
M: Andrew Lunn <andrew@lunn.ch>
10428
-
M: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
10421
+
M: Vivien Didelot <vivien.didelot@gmail.com>
10429
10422
M: Florian Fainelli <f.fainelli@gmail.com>
10430
10423
S: Maintained
10431
10424
F: Documentation/devicetree/bindings/net/dsa/
+7
drivers/crypto/chelsio/chtls/chtls.h
+7
drivers/crypto/chelsio/chtls/chtls.h
···
153
153
unsigned int cdev_state;
154
154
};
155
155
156
+
struct chtls_listen {
157
+
struct chtls_dev *cdev;
158
+
struct sock *sk;
159
+
};
160
+
156
161
struct chtls_hws {
157
162
struct sk_buff_head sk_recv_queue;
158
163
u8 txqid;
···
220
215
u16 resv2;
221
216
u32 delack_mode;
222
217
u32 delack_seq;
218
+
u32 snd_win;
219
+
u32 rcv_win;
223
220
224
221
void *passive_reap_next; /* placeholder for passive */
225
222
struct chtls_hws tlshws;
+52
-26
drivers/crypto/chelsio/chtls/chtls_cm.c
+52
-26
drivers/crypto/chelsio/chtls/chtls_cm.c
···
21
21
#include <linux/kallsyms.h>
22
22
#include <linux/kprobes.h>
23
23
#include <linux/if_vlan.h>
24
+
#include <net/inet_common.h>
24
25
#include <net/tcp.h>
25
26
#include <net/dst.h>
26
27
···
888
887
return mtu_idx;
889
888
}
890
889
891
-
static unsigned int select_rcv_wnd(struct chtls_sock *csk)
892
-
{
893
-
unsigned int rcvwnd;
894
-
unsigned int wnd;
895
-
struct sock *sk;
896
-
897
-
sk = csk->sk;
898
-
wnd = tcp_full_space(sk);
899
-
900
-
if (wnd < MIN_RCV_WND)
901
-
wnd = MIN_RCV_WND;
902
-
903
-
rcvwnd = MAX_RCV_WND;
904
-
905
-
csk_set_flag(csk, CSK_UPDATE_RCV_WND);
906
-
return min(wnd, rcvwnd);
907
-
}
908
-
909
890
static unsigned int select_rcv_wscale(int space, int wscale_ok, int win_clamp)
910
891
{
911
892
int wscale = 0;
···
934
951
csk->mtu_idx = chtls_select_mss(csk, dst_mtu(__sk_dst_get(sk)),
935
952
req);
936
953
opt0 = TCAM_BYPASS_F |
937
-
WND_SCALE_V((tp)->rx_opt.rcv_wscale) |
954
+
WND_SCALE_V(RCV_WSCALE(tp)) |
938
955
MSS_IDX_V(csk->mtu_idx) |
939
956
L2T_IDX_V(csk->l2t_entry->idx) |
940
957
NAGLE_V(!(tp->nonagle & TCP_NAGLE_OFF)) |
···
986
1003
}
987
1004
BLOG_SKB_CB(skb)->backlog_rcv(sk, skb);
988
1005
return 0;
1006
+
}
1007
+
1008
+
static void chtls_set_tcp_window(struct chtls_sock *csk)
1009
+
{
1010
+
struct net_device *ndev = csk->egress_dev;
1011
+
struct port_info *pi = netdev_priv(ndev);
1012
+
unsigned int linkspeed;
1013
+
u8 scale;
1014
+
1015
+
linkspeed = pi->link_cfg.speed;
1016
+
scale = linkspeed / SPEED_10000;
1017
+
#define CHTLS_10G_RCVWIN (256 * 1024)
1018
+
csk->rcv_win = CHTLS_10G_RCVWIN;
1019
+
if (scale)
1020
+
csk->rcv_win *= scale;
1021
+
#define CHTLS_10G_SNDWIN (256 * 1024)
1022
+
csk->snd_win = CHTLS_10G_SNDWIN;
1023
+
if (scale)
1024
+
csk->snd_win *= scale;
989
1025
}
990
1026
991
1027
static struct sock *chtls_recv_sock(struct sock *lsk,
···
1069
1067
csk->port_id = port_id;
1070
1068
csk->egress_dev = ndev;
1071
1069
csk->tos = PASS_OPEN_TOS_G(ntohl(req->tos_stid));
1070
+
chtls_set_tcp_window(csk);
1071
+
tp->rcv_wnd = csk->rcv_win;
1072
+
csk->sndbuf = csk->snd_win;
1072
1073
csk->ulp_mode = ULP_MODE_TLS;
1073
1074
step = cdev->lldi->nrxq / cdev->lldi->nchan;
1074
1075
csk->rss_qid = cdev->lldi->rxq_ids[port_id * step];
···
1081
1076
csk->sndbuf = newsk->sk_sndbuf;
1082
1077
csk->smac_idx = cxgb4_tp_smt_idx(cdev->lldi->adapter_type,
1083
1078
cxgb4_port_viid(ndev));
1084
-
tp->rcv_wnd = select_rcv_wnd(csk);
1085
1079
RCV_WSCALE(tp) = select_rcv_wscale(tcp_full_space(newsk),
1086
-
WSCALE_OK(tp),
1080
+
sock_net(newsk)->
1081
+
ipv4.sysctl_tcp_window_scaling,
1087
1082
tp->window_clamp);
1088
1083
neigh_release(n);
1089
1084
inet_inherit_port(&tcp_hashinfo, lsk, newsk);
···
1135
1130
struct cpl_t5_pass_accept_rpl *rpl;
1136
1131
struct cpl_pass_accept_req *req;
1137
1132
struct listen_ctx *listen_ctx;
1133
+
struct vlan_ethhdr *vlan_eh;
1138
1134
struct request_sock *oreq;
1139
1135
struct sk_buff *reply_skb;
1140
1136
struct chtls_sock *csk;
···
1148
1142
unsigned int stid;
1149
1143
unsigned int len;
1150
1144
unsigned int tid;
1145
+
bool th_ecn, ect;
1146
+
__u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */
1147
+
u16 eth_hdr_len;
1148
+
bool ecn_ok;
1151
1149
1152
1150
req = cplhdr(skb) + RSS_HDR;
1153
1151
tid = GET_TID(req);
···
1190
1180
oreq->mss = 0;
1191
1181
oreq->ts_recent = 0;
1192
1182
1193
-
eh = (struct ethhdr *)(req + 1);
1194
-
iph = (struct iphdr *)(eh + 1);
1183
+
eth_hdr_len = T6_ETH_HDR_LEN_G(ntohl(req->hdr_len));
1184
+
if (eth_hdr_len == ETH_HLEN) {
1185
+
eh = (struct ethhdr *)(req + 1);
1186
+
iph = (struct iphdr *)(eh + 1);
1187
+
network_hdr = (void *)(eh + 1);
1188
+
} else {
1189
+
vlan_eh = (struct vlan_ethhdr *)(req + 1);
1190
+
iph = (struct iphdr *)(vlan_eh + 1);
1191
+
network_hdr = (void *)(vlan_eh + 1);
1192
+
}
1195
1193
if (iph->version != 0x4)
1196
1194
goto free_oreq;
1197
1195
1198
-
network_hdr = (void *)(eh + 1);
1199
1196
tcph = (struct tcphdr *)(iph + 1);
1197
+
skb_set_network_header(skb, (void *)iph - (void *)req);
1200
1198
1201
1199
tcp_rsk(oreq)->tfo_listener = false;
1202
1200
tcp_rsk(oreq)->rcv_isn = ntohl(tcph->seq);
1203
1201
chtls_set_req_port(oreq, tcph->source, tcph->dest);
1204
-
inet_rsk(oreq)->ecn_ok = 0;
1205
1202
chtls_set_req_addr(oreq, iph->daddr, iph->saddr);
1206
-
if (req->tcpopt.wsf <= 14) {
1203
+
ip_dsfield = ipv4_get_dsfield(iph);
1204
+
if (req->tcpopt.wsf <= 14 &&
1205
+
sock_net(sk)->ipv4.sysctl_tcp_window_scaling) {
1207
1206
inet_rsk(oreq)->wscale_ok = 1;
1208
1207
inet_rsk(oreq)->snd_wscale = req->tcpopt.wsf;
1209
1208
}
1210
1209
inet_rsk(oreq)->ir_iif = sk->sk_bound_dev_if;
1210
+
th_ecn = tcph->ece && tcph->cwr;
1211
+
if (th_ecn) {
1212
+
ect = !INET_ECN_is_not_ect(ip_dsfield);
1213
+
ecn_ok = sock_net(sk)->ipv4.sysctl_tcp_ecn;
1214
+
if ((!ect && ecn_ok) || tcp_ca_needs_ecn(sk))
1215
+
inet_rsk(oreq)->ecn_ok = 1;
1216
+
}
1211
1217
1212
1218
newsk = chtls_recv_sock(sk, oreq, network_hdr, req, cdev);
1213
1219
if (!newsk)
+8
-12
drivers/crypto/chelsio/chtls/chtls_io.c
+8
-12
drivers/crypto/chelsio/chtls/chtls_io.c
···
397
397
398
398
req_wr->lsodisable_to_flags =
399
399
htonl(TX_ULP_MODE_V(ULP_MODE_TLS) |
400
-
FW_OFLD_TX_DATA_WR_URGENT_V(skb_urgent(skb)) |
400
+
TX_URG_V(skb_urgent(skb)) |
401
401
T6_TX_FORCE_F | wr_ulp_mode_force |
402
402
TX_SHOVE_V((!csk_flag(sk, CSK_TX_MORE_DATA)) &&
403
403
skb_queue_empty(&csk->txq)));
···
534
534
FW_OFLD_TX_DATA_WR_SHOVE_F);
535
535
536
536
req->tunnel_to_proxy = htonl(wr_ulp_mode_force |
537
-
FW_OFLD_TX_DATA_WR_URGENT_V(skb_urgent(skb)) |
538
-
FW_OFLD_TX_DATA_WR_SHOVE_V((!csk_flag
539
-
(sk, CSK_TX_MORE_DATA)) &&
540
-
skb_queue_empty(&csk->txq)));
537
+
TX_URG_V(skb_urgent(skb)) |
538
+
TX_SHOVE_V((!csk_flag(sk, CSK_TX_MORE_DATA)) &&
539
+
skb_queue_empty(&csk->txq)));
541
540
req->plen = htonl(len);
542
541
}
543
542
···
994
995
int mss, flags, err;
995
996
int recordsz = 0;
996
997
int copied = 0;
997
-
int hdrlen = 0;
998
998
long timeo;
999
999
1000
1000
lock_sock(sk);
···
1030
1032
1031
1033
recordsz = tls_header_read(&hdr, &msg->msg_iter);
1032
1034
size -= TLS_HEADER_LENGTH;
1033
-
hdrlen += TLS_HEADER_LENGTH;
1035
+
copied += TLS_HEADER_LENGTH;
1034
1036
csk->tlshws.txleft = recordsz;
1035
1037
csk->tlshws.type = hdr.type;
1036
1038
if (skb)
···
1081
1083
int off = TCP_OFF(sk);
1082
1084
bool merge;
1083
1085
1084
-
if (!page)
1085
-
goto wait_for_memory;
1086
-
1087
-
pg_size <<= compound_order(page);
1086
+
if (page)
1087
+
pg_size <<= compound_order(page);
1088
1088
if (off < pg_size &&
1089
1089
skb_can_coalesce(skb, i, page, off)) {
1090
1090
merge = 1;
···
1183
1187
chtls_tcp_push(sk, flags);
1184
1188
done:
1185
1189
release_sock(sk);
1186
-
return copied + hdrlen;
1190
+
return copied;
1187
1191
do_fault:
1188
1192
if (!skb->len) {
1189
1193
__skb_unlink(skb, &csk->txq);
+63
-42
drivers/crypto/chelsio/chtls/chtls_main.c
+63
-42
drivers/crypto/chelsio/chtls/chtls_main.c
···
55
55
static int listen_notify_handler(struct notifier_block *this,
56
56
unsigned long event, void *data)
57
57
{
58
-
struct chtls_dev *cdev;
59
-
struct sock *sk;
60
-
int ret;
58
+
struct chtls_listen *clisten;
59
+
int ret = NOTIFY_DONE;
61
60
62
-
sk = data;
63
-
ret = NOTIFY_DONE;
61
+
clisten = (struct chtls_listen *)data;
64
62
65
63
switch (event) {
66
64
case CHTLS_LISTEN_START:
65
+
ret = chtls_listen_start(clisten->cdev, clisten->sk);
66
+
kfree(clisten);
67
+
break;
67
68
case CHTLS_LISTEN_STOP:
68
-
mutex_lock(&cdev_list_lock);
69
-
list_for_each_entry(cdev, &cdev_list, list) {
70
-
if (event == CHTLS_LISTEN_START)
71
-
ret = chtls_listen_start(cdev, sk);
72
-
else
73
-
chtls_listen_stop(cdev, sk);
74
-
}
75
-
mutex_unlock(&cdev_list_lock);
69
+
chtls_listen_stop(clisten->cdev, clisten->sk);
70
+
kfree(clisten);
76
71
break;
77
72
}
78
73
return ret;
···
85
90
return 0;
86
91
}
87
92
88
-
static int chtls_start_listen(struct sock *sk)
93
+
static int chtls_start_listen(struct chtls_dev *cdev, struct sock *sk)
89
94
{
95
+
struct chtls_listen *clisten;
90
96
int err;
91
97
92
98
if (sk->sk_protocol != IPPROTO_TCP)
···
98
102
return -EADDRNOTAVAIL;
99
103
100
104
sk->sk_backlog_rcv = listen_backlog_rcv;
105
+
clisten = kmalloc(sizeof(*clisten), GFP_KERNEL);
106
+
if (!clisten)
107
+
return -ENOMEM;
108
+
clisten->cdev = cdev;
109
+
clisten->sk = sk;
101
110
mutex_lock(¬ify_mutex);
102
111
err = raw_notifier_call_chain(&listen_notify_list,
103
-
CHTLS_LISTEN_START, sk);
112
+
CHTLS_LISTEN_START, clisten);
104
113
mutex_unlock(¬ify_mutex);
105
114
return err;
106
115
}
107
116
108
-
static void chtls_stop_listen(struct sock *sk)
117
+
static void chtls_stop_listen(struct chtls_dev *cdev, struct sock *sk)
109
118
{
119
+
struct chtls_listen *clisten;
120
+
110
121
if (sk->sk_protocol != IPPROTO_TCP)
111
122
return;
112
123
124
+
clisten = kmalloc(sizeof(*clisten), GFP_KERNEL);
125
+
if (!clisten)
126
+
return;
127
+
clisten->cdev = cdev;
128
+
clisten->sk = sk;
113
129
mutex_lock(¬ify_mutex);
114
130
raw_notifier_call_chain(&listen_notify_list,
115
-
CHTLS_LISTEN_STOP, sk);
131
+
CHTLS_LISTEN_STOP, clisten);
116
132
mutex_unlock(¬ify_mutex);
117
133
}
118
134
···
146
138
147
139
static int chtls_create_hash(struct tls_device *dev, struct sock *sk)
148
140
{
141
+
struct chtls_dev *cdev = to_chtls_dev(dev);
142
+
149
143
if (sk->sk_state == TCP_LISTEN)
150
-
return chtls_start_listen(sk);
144
+
return chtls_start_listen(cdev, sk);
151
145
return 0;
152
146
}
153
147
154
148
static void chtls_destroy_hash(struct tls_device *dev, struct sock *sk)
155
149
{
150
+
struct chtls_dev *cdev = to_chtls_dev(dev);
151
+
156
152
if (sk->sk_state == TCP_LISTEN)
157
-
chtls_stop_listen(sk);
153
+
chtls_stop_listen(cdev, sk);
154
+
}
155
+
156
+
static void chtls_free_uld(struct chtls_dev *cdev)
157
+
{
158
+
int i;
159
+
160
+
tls_unregister_device(&cdev->tlsdev);
161
+
kvfree(cdev->kmap.addr);
162
+
idr_destroy(&cdev->hwtid_idr);
163
+
for (i = 0; i < (1 << RSPQ_HASH_BITS); i++)
164
+
kfree_skb(cdev->rspq_skb_cache[i]);
165
+
kfree(cdev->lldi);
166
+
kfree_skb(cdev->askb);
167
+
kfree(cdev);
168
+
}
169
+
170
+
static inline void chtls_dev_release(struct kref *kref)
171
+
{
172
+
struct chtls_dev *cdev;
173
+
struct tls_device *dev;
174
+
175
+
dev = container_of(kref, struct tls_device, kref);
176
+
cdev = to_chtls_dev(dev);
177
+
chtls_free_uld(cdev);
158
178
}
159
179
160
180
static void chtls_register_dev(struct chtls_dev *cdev)
···
195
159
tlsdev->feature = chtls_inline_feature;
196
160
tlsdev->hash = chtls_create_hash;
197
161
tlsdev->unhash = chtls_destroy_hash;
198
-
tls_register_device(&cdev->tlsdev);
162
+
tlsdev->release = chtls_dev_release;
163
+
kref_init(&tlsdev->kref);
164
+
tls_register_device(tlsdev);
199
165
cdev->cdev_state = CHTLS_CDEV_STATE_UP;
200
-
}
201
-
202
-
static void chtls_unregister_dev(struct chtls_dev *cdev)
203
-
{
204
-
tls_unregister_device(&cdev->tlsdev);
205
166
}
206
167
207
168
static void process_deferq(struct work_struct *task_param)
···
295
262
return NULL;
296
263
}
297
264
298
-
static void chtls_free_uld(struct chtls_dev *cdev)
299
-
{
300
-
int i;
301
-
302
-
chtls_unregister_dev(cdev);
303
-
kvfree(cdev->kmap.addr);
304
-
idr_destroy(&cdev->hwtid_idr);
305
-
for (i = 0; i < (1 << RSPQ_HASH_BITS); i++)
306
-
kfree_skb(cdev->rspq_skb_cache[i]);
307
-
kfree(cdev->lldi);
308
-
kfree_skb(cdev->askb);
309
-
kfree(cdev);
310
-
}
311
-
312
265
static void chtls_free_all_uld(void)
313
266
{
314
267
struct chtls_dev *cdev, *tmp;
315
268
316
269
mutex_lock(&cdev_mutex);
317
270
list_for_each_entry_safe(cdev, tmp, &cdev_list, list) {
318
-
if (cdev->cdev_state == CHTLS_CDEV_STATE_UP)
319
-
chtls_free_uld(cdev);
271
+
if (cdev->cdev_state == CHTLS_CDEV_STATE_UP) {
272
+
list_del(&cdev->list);
273
+
kref_put(&cdev->tlsdev.kref, cdev->tlsdev.release);
274
+
}
320
275
}
321
276
mutex_unlock(&cdev_mutex);
322
277
}
···
325
304
mutex_lock(&cdev_mutex);
326
305
list_del(&cdev->list);
327
306
mutex_unlock(&cdev_mutex);
328
-
chtls_free_uld(cdev);
307
+
kref_put(&cdev->tlsdev.kref, cdev->tlsdev.release);
329
308
break;
330
309
default:
331
310
break;
+1
-1
drivers/net/dsa/mv88e6xxx/chip.c
+1
-1
drivers/net/dsa/mv88e6xxx/chip.c
-3
drivers/net/ethernet/apm/xgene/xgene_enet_main.c
-3
drivers/net/ethernet/apm/xgene/xgene_enet_main.c
···
29
29
#define RES_RING_CSR 1
30
30
#define RES_RING_CMD 2
31
31
32
-
static const struct of_device_id xgene_enet_of_match[];
33
-
static const struct acpi_device_id xgene_enet_acpi_match[];
34
-
35
32
static void xgene_enet_init_bufpool(struct xgene_enet_desc_ring *buf_pool)
36
33
{
37
34
struct xgene_enet_raw_desc16 *raw_desc;
+2
drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+2
drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
···
1282
1282
BNX2X_SP_RTNL_TX_STOP,
1283
1283
BNX2X_SP_RTNL_GET_DRV_VERSION,
1284
1284
BNX2X_SP_RTNL_CHANGE_UDP_PORT,
1285
+
BNX2X_SP_RTNL_UPDATE_SVID,
1285
1286
};
1286
1287
1287
1288
enum bnx2x_iov_flag {
···
2521
2520
void bnx2x_init_ptp(struct bnx2x *bp);
2522
2521
int bnx2x_configure_ptp_filters(struct bnx2x *bp);
2523
2522
void bnx2x_set_rx_ts(struct bnx2x *bp, struct sk_buff *skb);
2523
+
void bnx2x_register_phc(struct bnx2x *bp);
2524
2524
2525
2525
#define BNX2X_MAX_PHC_DRIFT 31000000
2526
2526
#define BNX2X_PTP_TX_TIMEOUT
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+49
-21
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+49
-21
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
···
2925
2925
func_params.f_obj = &bp->func_obj;
2926
2926
func_params.cmd = BNX2X_F_CMD_SWITCH_UPDATE;
2927
2927
2928
+
/* Prepare parameters for function state transitions */
2929
+
__set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
2930
+
__set_bit(RAMROD_RETRY, &func_params.ramrod_flags);
2931
+
2928
2932
if (IS_MF_UFP(bp) || IS_MF_BD(bp)) {
2929
2933
int func = BP_ABS_FUNC(bp);
2930
2934
u32 val;
···
4315
4311
bnx2x_handle_eee_event(bp);
4316
4312
4317
4313
if (val & DRV_STATUS_OEM_UPDATE_SVID)
4318
-
bnx2x_handle_update_svid_cmd(bp);
4314
+
bnx2x_schedule_sp_rtnl(bp,
4315
+
BNX2X_SP_RTNL_UPDATE_SVID, 0);
4319
4316
4320
4317
if (bp->link_vars.periodic_flags &
4321
4318
PERIODIC_FLAGS_LINK_EVENT) {
···
7728
7723
REG_WR(bp, reg_addr, val);
7729
7724
}
7730
7725
7726
+
if (CHIP_IS_E3B0(bp))
7727
+
bp->flags |= PTP_SUPPORTED;
7728
+
7731
7729
return 0;
7732
7730
}
7733
7731
···
8480
8472
/* Fill a user request section if needed */
8481
8473
if (!test_bit(RAMROD_CONT, ramrod_flags)) {
8482
8474
ramrod_param.user_req.u.vlan.vlan = vlan;
8475
+
__set_bit(BNX2X_VLAN, &ramrod_param.user_req.vlan_mac_flags);
8483
8476
/* Set the command: ADD or DEL */
8484
8477
if (set)
8485
8478
ramrod_param.user_req.cmd = BNX2X_VLAN_MAC_ADD;
···
8499
8490
}
8500
8491
8501
8492
return rc;
8493
+
}
8494
+
8495
+
static int bnx2x_del_all_vlans(struct bnx2x *bp)
8496
+
{
8497
+
struct bnx2x_vlan_mac_obj *vlan_obj = &bp->sp_objs[0].vlan_obj;
8498
+
unsigned long ramrod_flags = 0, vlan_flags = 0;
8499
+
struct bnx2x_vlan_entry *vlan;
8500
+
int rc;
8501
+
8502
+
__set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
8503
+
__set_bit(BNX2X_VLAN, &vlan_flags);
8504
+
rc = vlan_obj->delete_all(bp, vlan_obj, &vlan_flags, &ramrod_flags);
8505
+
if (rc)
8506
+
return rc;
8507
+
8508
+
/* Mark that hw forgot all entries */
8509
+
list_for_each_entry(vlan, &bp->vlan_reg, link)
8510
+
vlan->hw = false;
8511
+
bp->vlan_cnt = 0;
8512
+
8513
+
return 0;
8502
8514
}
8503
8515
8504
8516
int bnx2x_del_all_macs(struct bnx2x *bp,
···
9360
9330
BNX2X_ERR("Failed to schedule DEL commands for UC MACs list: %d\n",
9361
9331
rc);
9362
9332
9333
+
/* Remove all currently configured VLANs */
9334
+
rc = bnx2x_del_all_vlans(bp);
9335
+
if (rc < 0)
9336
+
BNX2X_ERR("Failed to delete all VLANs\n");
9337
+
9363
9338
/* Disable LLH */
9364
9339
if (!CHIP_IS_E1(bp))
9365
9340
REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
···
9452
9417
* function stop ramrod is sent, since as part of this ramrod FW access
9453
9418
* PTP registers.
9454
9419
*/
9455
-
if (bp->flags & PTP_SUPPORTED)
9420
+
if (bp->flags & PTP_SUPPORTED) {
9456
9421
bnx2x_stop_ptp(bp);
9422
+
if (bp->ptp_clock) {
9423
+
ptp_clock_unregister(bp->ptp_clock);
9424
+
bp->ptp_clock = NULL;
9425
+
}
9426
+
}
9457
9427
9458
9428
/* Disable HW interrupts, NAPI */
9459
9429
bnx2x_netif_stop(bp, 1);
···
10398
10358
if (test_and_clear_bit(BNX2X_SP_RTNL_GET_DRV_VERSION,
10399
10359
&bp->sp_rtnl_state))
10400
10360
bnx2x_update_mng_version(bp);
10361
+
10362
+
if (test_and_clear_bit(BNX2X_SP_RTNL_UPDATE_SVID, &bp->sp_rtnl_state))
10363
+
bnx2x_handle_update_svid_cmd(bp);
10401
10364
10402
10365
if (test_and_clear_bit(BNX2X_SP_RTNL_CHANGE_UDP_PORT,
10403
10366
&bp->sp_rtnl_state)) {
···
11793
11750
* If maximum allowed number of connections is zero -
11794
11751
* disable the feature.
11795
11752
*/
11796
-
if (!bp->cnic_eth_dev.max_fcoe_conn)
11753
+
if (!bp->cnic_eth_dev.max_fcoe_conn) {
11797
11754
bp->flags |= NO_FCOE_FLAG;
11755
+
eth_zero_addr(bp->fip_mac);
11756
+
}
11798
11757
}
11799
11758
11800
11759
static void bnx2x_get_cnic_info(struct bnx2x *bp)
···
12539
12494
12540
12495
bp->dump_preset_idx = 1;
12541
12496
12542
-
if (CHIP_IS_E3B0(bp))
12543
-
bp->flags |= PTP_SUPPORTED;
12544
-
12545
12497
return rc;
12546
12498
}
12547
12499
···
13066
13024
13067
13025
int bnx2x_vlan_reconfigure_vid(struct bnx2x *bp)
13068
13026
{
13069
-
struct bnx2x_vlan_entry *vlan;
13070
-
13071
-
/* The hw forgot all entries after reload */
13072
-
list_for_each_entry(vlan, &bp->vlan_reg, link)
13073
-
vlan->hw = false;
13074
-
bp->vlan_cnt = 0;
13075
-
13076
13027
/* Don't set rx mode here. Our caller will do it. */
13077
13028
bnx2x_vlan_configure(bp, false);
13078
13029
···
13930
13895
return -ENOTSUPP;
13931
13896
}
13932
13897
13933
-
static void bnx2x_register_phc(struct bnx2x *bp)
13898
+
void bnx2x_register_phc(struct bnx2x *bp)
13934
13899
{
13935
13900
/* Fill the ptp_clock_info struct and register PTP clock*/
13936
13901
bp->ptp_clock_info.owner = THIS_MODULE;
···
14132
14097
dev->base_addr, bp->pdev->irq, dev->dev_addr);
14133
14098
pcie_print_link_status(bp->pdev);
14134
14099
14135
-
bnx2x_register_phc(bp);
14136
-
14137
14100
if (!IS_MF_SD_STORAGE_PERSONALITY_ONLY(bp))
14138
14101
bnx2x_set_os_driver_state(bp, OS_DRIVER_STATE_DISABLED);
14139
14102
···
14164
14131
struct bnx2x *bp,
14165
14132
bool remove_netdev)
14166
14133
{
14167
-
if (bp->ptp_clock) {
14168
-
ptp_clock_unregister(bp->ptp_clock);
14169
-
bp->ptp_clock = NULL;
14170
-
}
14171
-
14172
14134
/* Delete storage MAC address */
14173
14135
if (!NO_FCOE(bp)) {
14174
14136
rtnl_lock();
+3
-1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h
+3
-1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h
···
265
265
BNX2X_ETH_MAC,
266
266
BNX2X_ISCSI_ETH_MAC,
267
267
BNX2X_NETQ_ETH_MAC,
268
+
BNX2X_VLAN,
268
269
BNX2X_DONT_CONSUME_CAM_CREDIT,
269
270
BNX2X_DONT_CONSUME_CAM_CREDIT_DEST,
270
271
};
···
273
272
#define BNX2X_VLAN_MAC_CMP_MASK (1 << BNX2X_UC_LIST_MAC | \
274
273
1 << BNX2X_ETH_MAC | \
275
274
1 << BNX2X_ISCSI_ETH_MAC | \
276
-
1 << BNX2X_NETQ_ETH_MAC)
275
+
1 << BNX2X_NETQ_ETH_MAC | \
276
+
1 << BNX2X_VLAN)
277
277
#define BNX2X_VLAN_MAC_CMP_FLAGS(flags) \
278
278
((flags) & BNX2X_VLAN_MAC_CMP_MASK)
279
279
+4
-1
drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
+4
-1
drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
···
2572
2572
static int bnxt_run_loopback(struct bnxt *bp)
2573
2573
{
2574
2574
struct bnxt_tx_ring_info *txr = &bp->tx_ring[0];
2575
+
struct bnxt_rx_ring_info *rxr = &bp->rx_ring[0];
2575
2576
struct bnxt_cp_ring_info *cpr;
2576
2577
int pkt_size, i = 0;
2577
2578
struct sk_buff *skb;
···
2580
2579
u8 *data;
2581
2580
int rc;
2582
2581
2583
-
cpr = &txr->bnapi->cp_ring;
2582
+
cpr = &rxr->bnapi->cp_ring;
2583
+
if (bp->flags & BNXT_FLAG_CHIP_P5)
2584
+
cpr = cpr->cp_ring_arr[BNXT_RX_HDL];
2584
2585
pkt_size = min(bp->dev->mtu + ETH_HLEN, bp->rx_copy_thresh);
2585
2586
skb = netdev_alloc_skb(bp->dev, pkt_size);
2586
2587
if (!skb)
+42
-6
drivers/net/ethernet/cadence/macb_main.c
+42
-6
drivers/net/ethernet/cadence/macb_main.c
···
61
61
#define MACB_TX_ERR_FLAGS (MACB_BIT(ISR_TUND) \
62
62
| MACB_BIT(ISR_RLE) \
63
63
| MACB_BIT(TXERR))
64
-
#define MACB_TX_INT_FLAGS (MACB_TX_ERR_FLAGS | MACB_BIT(TCOMP))
64
+
#define MACB_TX_INT_FLAGS (MACB_TX_ERR_FLAGS | MACB_BIT(TCOMP) \
65
+
| MACB_BIT(TXUBR))
65
66
66
67
/* Max length of transmit frame must be a multiple of 8 bytes */
67
68
#define MACB_TX_LEN_ALIGN 8
···
681
680
if (bp->hw_dma_cap & HW_DMA_CAP_64B) {
682
681
desc_64 = macb_64b_desc(bp, desc);
683
682
desc_64->addrh = upper_32_bits(addr);
683
+
/* The low bits of RX address contain the RX_USED bit, clearing
684
+
* of which allows packet RX. Make sure the high bits are also
685
+
* visible to HW at that point.
686
+
*/
687
+
dma_wmb();
684
688
}
685
689
#endif
686
690
desc->addr = lower_32_bits(addr);
···
934
928
935
929
if (entry == bp->rx_ring_size - 1)
936
930
paddr |= MACB_BIT(RX_WRAP);
937
-
macb_set_addr(bp, desc, paddr);
938
931
desc->ctrl = 0;
932
+
/* Setting addr clears RX_USED and allows reception,
933
+
* make sure ctrl is cleared first to avoid a race.
934
+
*/
935
+
dma_wmb();
936
+
macb_set_addr(bp, desc, paddr);
939
937
940
938
/* properly align Ethernet header */
941
939
skb_reserve(skb, NET_IP_ALIGN);
942
940
} else {
943
-
desc->addr &= ~MACB_BIT(RX_USED);
944
941
desc->ctrl = 0;
942
+
dma_wmb();
943
+
desc->addr &= ~MACB_BIT(RX_USED);
945
944
}
946
945
}
947
946
···
1000
989
1001
990
rxused = (desc->addr & MACB_BIT(RX_USED)) ? true : false;
1002
991
addr = macb_get_addr(bp, desc);
1003
-
ctrl = desc->ctrl;
1004
992
1005
993
if (!rxused)
1006
994
break;
995
+
996
+
/* Ensure ctrl is at least as up-to-date as rxused */
997
+
dma_rmb();
998
+
999
+
ctrl = desc->ctrl;
1007
1000
1008
1001
queue->rx_tail++;
1009
1002
count++;
···
1183
1168
/* Make hw descriptor updates visible to CPU */
1184
1169
rmb();
1185
1170
1186
-
ctrl = desc->ctrl;
1187
-
1188
1171
if (!(desc->addr & MACB_BIT(RX_USED)))
1189
1172
break;
1173
+
1174
+
/* Ensure ctrl is at least as up-to-date as addr */
1175
+
dma_rmb();
1176
+
1177
+
ctrl = desc->ctrl;
1190
1178
1191
1179
if (ctrl & MACB_BIT(RX_SOF)) {
1192
1180
if (first_frag != -1)
···
1330
1312
netif_tx_start_all_queues(dev);
1331
1313
}
1332
1314
1315
+
static void macb_tx_restart(struct macb_queue *queue)
1316
+
{
1317
+
unsigned int head = queue->tx_head;
1318
+
unsigned int tail = queue->tx_tail;
1319
+
struct macb *bp = queue->bp;
1320
+
1321
+
if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1322
+
queue_writel(queue, ISR, MACB_BIT(TXUBR));
1323
+
1324
+
if (head == tail)
1325
+
return;
1326
+
1327
+
macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TSTART));
1328
+
}
1329
+
1333
1330
static irqreturn_t macb_interrupt(int irq, void *dev_id)
1334
1331
{
1335
1332
struct macb_queue *queue = dev_id;
···
1401
1368
1402
1369
if (status & MACB_BIT(TCOMP))
1403
1370
macb_tx_interrupt(queue);
1371
+
1372
+
if (status & MACB_BIT(TXUBR))
1373
+
macb_tx_restart(queue);
1404
1374
1405
1375
/* Link change detection isn't possible with RMII, so we'll
1406
1376
* add that if/when we get our hands on a full-blown MII PHY.
+2
drivers/net/ethernet/cadence/macb_ptp.c
+2
drivers/net/ethernet/cadence/macb_ptp.c
···
319
319
desc_ptp = macb_ptp_desc(queue->bp, desc);
320
320
tx_timestamp = &queue->tx_timestamps[head];
321
321
tx_timestamp->skb = skb;
322
+
/* ensure ts_1/ts_2 is loaded after ctrl (TX_USED check) */
323
+
dma_rmb();
322
324
tx_timestamp->desc_ptp.ts_1 = desc_ptp->ts_1;
323
325
tx_timestamp->desc_ptp.ts_2 = desc_ptp->ts_2;
324
326
/* move head */
+3
drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
+3
drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
+3
drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
+3
drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
+10
-4
drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
+10
-4
drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
···
67
67
struct mac_driver *drv = (struct mac_driver *)mac_drv;
68
68
69
69
/*enable GE rX/tX */
70
-
if ((mode == MAC_COMM_MODE_TX) || (mode == MAC_COMM_MODE_RX_AND_TX))
70
+
if (mode == MAC_COMM_MODE_TX || mode == MAC_COMM_MODE_RX_AND_TX)
71
71
dsaf_set_dev_bit(drv, GMAC_PORT_EN_REG, GMAC_PORT_TX_EN_B, 1);
72
72
73
-
if ((mode == MAC_COMM_MODE_RX) || (mode == MAC_COMM_MODE_RX_AND_TX))
73
+
if (mode == MAC_COMM_MODE_RX || mode == MAC_COMM_MODE_RX_AND_TX) {
74
+
/* enable rx pcs */
75
+
dsaf_set_dev_bit(drv, GMAC_PCS_RX_EN_REG, 0, 0);
74
76
dsaf_set_dev_bit(drv, GMAC_PORT_EN_REG, GMAC_PORT_RX_EN_B, 1);
77
+
}
75
78
}
76
79
77
80
static void hns_gmac_disable(void *mac_drv, enum mac_commom_mode mode)
···
82
79
struct mac_driver *drv = (struct mac_driver *)mac_drv;
83
80
84
81
/*disable GE rX/tX */
85
-
if ((mode == MAC_COMM_MODE_TX) || (mode == MAC_COMM_MODE_RX_AND_TX))
82
+
if (mode == MAC_COMM_MODE_TX || mode == MAC_COMM_MODE_RX_AND_TX)
86
83
dsaf_set_dev_bit(drv, GMAC_PORT_EN_REG, GMAC_PORT_TX_EN_B, 0);
87
84
88
-
if ((mode == MAC_COMM_MODE_RX) || (mode == MAC_COMM_MODE_RX_AND_TX))
85
+
if (mode == MAC_COMM_MODE_RX || mode == MAC_COMM_MODE_RX_AND_TX) {
86
+
/* disable rx pcs */
87
+
dsaf_set_dev_bit(drv, GMAC_PCS_RX_EN_REG, 0, 1);
89
88
dsaf_set_dev_bit(drv, GMAC_PORT_EN_REG, GMAC_PORT_RX_EN_B, 0);
89
+
}
90
90
}
91
91
92
92
/* hns_gmac_get_en - get port enable
+15
drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c
+15
drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c
···
778
778
return rc;
779
779
}
780
780
781
+
static void hns_mac_remove_phydev(struct hns_mac_cb *mac_cb)
782
+
{
783
+
if (!to_acpi_device_node(mac_cb->fw_port) || !mac_cb->phy_dev)
784
+
return;
785
+
786
+
phy_device_remove(mac_cb->phy_dev);
787
+
phy_device_free(mac_cb->phy_dev);
788
+
789
+
mac_cb->phy_dev = NULL;
790
+
}
791
+
781
792
#define MAC_MEDIA_TYPE_MAX_LEN 16
782
793
783
794
static const struct {
···
1128
1117
int max_port_num = hns_mac_get_max_port_num(dsaf_dev);
1129
1118
1130
1119
for (i = 0; i < max_port_num; i++) {
1120
+
if (!dsaf_dev->mac_cb[i])
1121
+
continue;
1122
+
1131
1123
dsaf_dev->misc_op->cpld_reset_led(dsaf_dev->mac_cb[i]);
1124
+
hns_mac_remove_phydev(dsaf_dev->mac_cb[i]);
1132
1125
dsaf_dev->mac_cb[i] = NULL;
1133
1126
}
1134
1127
}
+349
-174
drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
+349
-174
drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
···
935
935
}
936
936
937
937
/**
938
+
* hns_dsaf_tcam_uc_cfg_vague - INT
939
+
* @dsaf_dev: dsa fabric device struct pointer
940
+
* @address,
941
+
* @ptbl_tcam_data,
942
+
*/
943
+
static void hns_dsaf_tcam_uc_cfg_vague(struct dsaf_device *dsaf_dev,
944
+
u32 address,
945
+
struct dsaf_tbl_tcam_data *tcam_data,
946
+
struct dsaf_tbl_tcam_data *tcam_mask,
947
+
struct dsaf_tbl_tcam_ucast_cfg *tcam_uc)
948
+
{
949
+
spin_lock_bh(&dsaf_dev->tcam_lock);
950
+
hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
951
+
hns_dsaf_tbl_tcam_data_cfg(dsaf_dev, tcam_data);
952
+
hns_dsaf_tbl_tcam_ucast_cfg(dsaf_dev, tcam_uc);
953
+
hns_dsaf_tbl_tcam_match_cfg(dsaf_dev, tcam_mask);
954
+
hns_dsaf_tbl_tcam_data_ucast_pul(dsaf_dev);
955
+
956
+
/*Restore Match Data*/
957
+
tcam_mask->tbl_tcam_data_high = 0xffffffff;
958
+
tcam_mask->tbl_tcam_data_low = 0xffffffff;
959
+
hns_dsaf_tbl_tcam_match_cfg(dsaf_dev, tcam_mask);
960
+
961
+
spin_unlock_bh(&dsaf_dev->tcam_lock);
962
+
}
963
+
964
+
/**
965
+
* hns_dsaf_tcam_mc_cfg_vague - INT
966
+
* @dsaf_dev: dsa fabric device struct pointer
967
+
* @address,
968
+
* @ptbl_tcam_data,
969
+
* @ptbl_tcam_mask
970
+
* @ptbl_tcam_mcast
971
+
*/
972
+
static void hns_dsaf_tcam_mc_cfg_vague(struct dsaf_device *dsaf_dev,
973
+
u32 address,
974
+
struct dsaf_tbl_tcam_data *tcam_data,
975
+
struct dsaf_tbl_tcam_data *tcam_mask,
976
+
struct dsaf_tbl_tcam_mcast_cfg *tcam_mc)
977
+
{
978
+
spin_lock_bh(&dsaf_dev->tcam_lock);
979
+
hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
980
+
hns_dsaf_tbl_tcam_data_cfg(dsaf_dev, tcam_data);
981
+
hns_dsaf_tbl_tcam_mcast_cfg(dsaf_dev, tcam_mc);
982
+
hns_dsaf_tbl_tcam_match_cfg(dsaf_dev, tcam_mask);
983
+
hns_dsaf_tbl_tcam_data_mcast_pul(dsaf_dev);
984
+
985
+
/*Restore Match Data*/
986
+
tcam_mask->tbl_tcam_data_high = 0xffffffff;
987
+
tcam_mask->tbl_tcam_data_low = 0xffffffff;
988
+
hns_dsaf_tbl_tcam_match_cfg(dsaf_dev, tcam_mask);
989
+
990
+
spin_unlock_bh(&dsaf_dev->tcam_lock);
991
+
}
992
+
993
+
/**
938
994
* hns_dsaf_tcam_mc_invld - INT
939
995
* @dsaf_id: dsa fabric id
940
996
* @address
···
1544
1488
return i;
1545
1489
1546
1490
soft_mac_entry++;
1491
+
}
1492
+
return DSAF_INVALID_ENTRY_IDX;
1493
+
}
1494
+
1495
+
/**
1496
+
* hns_dsaf_find_empty_mac_entry_reverse
1497
+
* search dsa fabric soft empty-entry from the end
1498
+
* @dsaf_dev: dsa fabric device struct pointer
1499
+
*/
1500
+
static u16 hns_dsaf_find_empty_mac_entry_reverse(struct dsaf_device *dsaf_dev)
1501
+
{
1502
+
struct dsaf_drv_priv *priv = hns_dsaf_dev_priv(dsaf_dev);
1503
+
struct dsaf_drv_soft_mac_tbl *soft_mac_entry;
1504
+
int i;
1505
+
1506
+
soft_mac_entry = priv->soft_mac_tbl + (DSAF_TCAM_SUM - 1);
1507
+
for (i = (DSAF_TCAM_SUM - 1); i > 0; i--) {
1508
+
/* search all entry from end to start.*/
1509
+
if (soft_mac_entry->index == DSAF_INVALID_ENTRY_IDX)
1510
+
return i;
1511
+
soft_mac_entry--;
1547
1512
}
1548
1513
return DSAF_INVALID_ENTRY_IDX;
1549
1514
}
···
2243
2166
DSAF_INODE_LOCAL_ADDR_FALSE_NUM_0_REG + 0x80 * (u64)node_num);
2244
2167
2245
2168
hw_stats->vlan_drop += dsaf_read_dev(dsaf_dev,
2246
-
DSAF_INODE_SW_VLAN_TAG_DISC_0_REG + 0x80 * (u64)node_num);
2169
+
DSAF_INODE_SW_VLAN_TAG_DISC_0_REG + 4 * (u64)node_num);
2247
2170
hw_stats->stp_drop += dsaf_read_dev(dsaf_dev,
2248
-
DSAF_INODE_IN_DATA_STP_DISC_0_REG + 0x80 * (u64)node_num);
2171
+
DSAF_INODE_IN_DATA_STP_DISC_0_REG + 4 * (u64)node_num);
2249
2172
2250
2173
/* pfc pause frame statistics stored in dsaf inode*/
2251
2174
if ((node_num < DSAF_SERVICE_NW_NUM) && !is_ver1) {
···
2362
2285
DSAF_INODE_BD_ORDER_STATUS_0_REG + j * 4);
2363
2286
p[223 + i] = dsaf_read_dev(ddev,
2364
2287
DSAF_INODE_SW_VLAN_TAG_DISC_0_REG + j * 4);
2365
-
p[224 + i] = dsaf_read_dev(ddev,
2288
+
p[226 + i] = dsaf_read_dev(ddev,
2366
2289
DSAF_INODE_IN_DATA_STP_DISC_0_REG + j * 4);
2367
2290
}
2368
2291
2369
-
p[227] = dsaf_read_dev(ddev, DSAF_INODE_GE_FC_EN_0_REG + port * 4);
2292
+
p[229] = dsaf_read_dev(ddev, DSAF_INODE_GE_FC_EN_0_REG + port * 4);
2370
2293
2371
2294
for (i = 0; i < DSAF_INODE_NUM / DSAF_COMM_CHN; i++) {
2372
2295
j = i * DSAF_COMM_CHN + port;
2373
-
p[228 + i] = dsaf_read_dev(ddev,
2296
+
p[230 + i] = dsaf_read_dev(ddev,
2374
2297
DSAF_INODE_VC0_IN_PKT_NUM_0_REG + j * 4);
2375
2298
}
2376
2299
2377
-
p[231] = dsaf_read_dev(ddev,
2378
-
DSAF_INODE_VC1_IN_PKT_NUM_0_REG + port * 4);
2300
+
p[233] = dsaf_read_dev(ddev,
2301
+
DSAF_INODE_VC1_IN_PKT_NUM_0_REG + port * 0x80);
2379
2302
2380
2303
/* dsaf inode registers */
2381
2304
for (i = 0; i < HNS_DSAF_SBM_NUM(ddev) / DSAF_COMM_CHN; i++) {
2382
2305
j = i * DSAF_COMM_CHN + port;
2383
-
p[232 + i] = dsaf_read_dev(ddev,
2306
+
p[234 + i] = dsaf_read_dev(ddev,
2384
2307
DSAF_SBM_CFG_REG_0_REG + j * 0x80);
2385
-
p[235 + i] = dsaf_read_dev(ddev,
2308
+
p[237 + i] = dsaf_read_dev(ddev,
2386
2309
DSAF_SBM_BP_CFG_0_XGE_REG_0_REG + j * 0x80);
2387
-
p[238 + i] = dsaf_read_dev(ddev,
2310
+
p[240 + i] = dsaf_read_dev(ddev,
2388
2311
DSAF_SBM_BP_CFG_1_REG_0_REG + j * 0x80);
2389
-
p[241 + i] = dsaf_read_dev(ddev,
2312
+
p[243 + i] = dsaf_read_dev(ddev,
2390
2313
DSAF_SBM_BP_CFG_2_XGE_REG_0_REG + j * 0x80);
2391
-
p[244 + i] = dsaf_read_dev(ddev,
2314
+
p[246 + i] = dsaf_read_dev(ddev,
2392
2315
DSAF_SBM_FREE_CNT_0_0_REG + j * 0x80);
2393
-
p[245 + i] = dsaf_read_dev(ddev,
2316
+
p[249 + i] = dsaf_read_dev(ddev,
2394
2317
DSAF_SBM_FREE_CNT_1_0_REG + j * 0x80);
2395
-
p[248 + i] = dsaf_read_dev(ddev,
2318
+
p[252 + i] = dsaf_read_dev(ddev,
2396
2319
DSAF_SBM_BP_CNT_0_0_REG + j * 0x80);
2397
-
p[251 + i] = dsaf_read_dev(ddev,
2320
+
p[255 + i] = dsaf_read_dev(ddev,
2398
2321
DSAF_SBM_BP_CNT_1_0_REG + j * 0x80);
2399
-
p[254 + i] = dsaf_read_dev(ddev,
2322
+
p[258 + i] = dsaf_read_dev(ddev,
2400
2323
DSAF_SBM_BP_CNT_2_0_REG + j * 0x80);
2401
-
p[257 + i] = dsaf_read_dev(ddev,
2324
+
p[261 + i] = dsaf_read_dev(ddev,
2402
2325
DSAF_SBM_BP_CNT_3_0_REG + j * 0x80);
2403
-
p[260 + i] = dsaf_read_dev(ddev,
2326
+
p[264 + i] = dsaf_read_dev(ddev,
2404
2327
DSAF_SBM_INER_ST_0_REG + j * 0x80);
2405
-
p[263 + i] = dsaf_read_dev(ddev,
2328
+
p[267 + i] = dsaf_read_dev(ddev,
2406
2329
DSAF_SBM_MIB_REQ_FAILED_TC_0_REG + j * 0x80);
2407
-
p[266 + i] = dsaf_read_dev(ddev,
2330
+
p[270 + i] = dsaf_read_dev(ddev,
2408
2331
DSAF_SBM_LNK_INPORT_CNT_0_REG + j * 0x80);
2409
-
p[269 + i] = dsaf_read_dev(ddev,
2332
+
p[273 + i] = dsaf_read_dev(ddev,
2410
2333
DSAF_SBM_LNK_DROP_CNT_0_REG + j * 0x80);
2411
-
p[272 + i] = dsaf_read_dev(ddev,
2334
+
p[276 + i] = dsaf_read_dev(ddev,
2412
2335
DSAF_SBM_INF_OUTPORT_CNT_0_REG + j * 0x80);
2413
-
p[275 + i] = dsaf_read_dev(ddev,
2336
+
p[279 + i] = dsaf_read_dev(ddev,
2414
2337
DSAF_SBM_LNK_INPORT_TC0_CNT_0_REG + j * 0x80);
2415
-
p[278 + i] = dsaf_read_dev(ddev,
2338
+
p[282 + i] = dsaf_read_dev(ddev,
2416
2339
DSAF_SBM_LNK_INPORT_TC1_CNT_0_REG + j * 0x80);
2417
-
p[281 + i] = dsaf_read_dev(ddev,
2340
+
p[285 + i] = dsaf_read_dev(ddev,
2418
2341
DSAF_SBM_LNK_INPORT_TC2_CNT_0_REG + j * 0x80);
2419
-
p[284 + i] = dsaf_read_dev(ddev,
2342
+
p[288 + i] = dsaf_read_dev(ddev,
2420
2343
DSAF_SBM_LNK_INPORT_TC3_CNT_0_REG + j * 0x80);
2421
-
p[287 + i] = dsaf_read_dev(ddev,
2344
+
p[291 + i] = dsaf_read_dev(ddev,
2422
2345
DSAF_SBM_LNK_INPORT_TC4_CNT_0_REG + j * 0x80);
2423
-
p[290 + i] = dsaf_read_dev(ddev,
2346
+
p[294 + i] = dsaf_read_dev(ddev,
2424
2347
DSAF_SBM_LNK_INPORT_TC5_CNT_0_REG + j * 0x80);
2425
-
p[293 + i] = dsaf_read_dev(ddev,
2348
+
p[297 + i] = dsaf_read_dev(ddev,
2426
2349
DSAF_SBM_LNK_INPORT_TC6_CNT_0_REG + j * 0x80);
2427
-
p[296 + i] = dsaf_read_dev(ddev,
2350
+
p[300 + i] = dsaf_read_dev(ddev,
2428
2351
DSAF_SBM_LNK_INPORT_TC7_CNT_0_REG + j * 0x80);
2429
-
p[299 + i] = dsaf_read_dev(ddev,
2352
+
p[303 + i] = dsaf_read_dev(ddev,
2430
2353
DSAF_SBM_LNK_REQ_CNT_0_REG + j * 0x80);
2431
-
p[302 + i] = dsaf_read_dev(ddev,
2354
+
p[306 + i] = dsaf_read_dev(ddev,
2432
2355
DSAF_SBM_LNK_RELS_CNT_0_REG + j * 0x80);
2433
-
p[305 + i] = dsaf_read_dev(ddev,
2356
+
p[309 + i] = dsaf_read_dev(ddev,
2434
2357
DSAF_SBM_BP_CFG_3_REG_0_REG + j * 0x80);
2435
-
p[308 + i] = dsaf_read_dev(ddev,
2358
+
p[312 + i] = dsaf_read_dev(ddev,
2436
2359
DSAF_SBM_BP_CFG_4_REG_0_REG + j * 0x80);
2437
2360
}
2438
2361
2439
2362
/* dsaf onode registers */
2440
2363
for (i = 0; i < DSAF_XOD_NUM; i++) {
2441
-
p[311 + i] = dsaf_read_dev(ddev,
2364
+
p[315 + i] = dsaf_read_dev(ddev,
2442
2365
DSAF_XOD_ETS_TSA_TC0_TC3_CFG_0_REG + i * 0x90);
2443
-
p[319 + i] = dsaf_read_dev(ddev,
2366
+
p[323 + i] = dsaf_read_dev(ddev,
2444
2367
DSAF_XOD_ETS_TSA_TC4_TC7_CFG_0_REG + i * 0x90);
2445
-
p[327 + i] = dsaf_read_dev(ddev,
2368
+
p[331 + i] = dsaf_read_dev(ddev,
2446
2369
DSAF_XOD_ETS_BW_TC0_TC3_CFG_0_REG + i * 0x90);
2447
-
p[335 + i] = dsaf_read_dev(ddev,
2370
+
p[339 + i] = dsaf_read_dev(ddev,
2448
2371
DSAF_XOD_ETS_BW_TC4_TC7_CFG_0_REG + i * 0x90);
2449
-
p[343 + i] = dsaf_read_dev(ddev,
2372
+
p[347 + i] = dsaf_read_dev(ddev,
2450
2373
DSAF_XOD_ETS_BW_OFFSET_CFG_0_REG + i * 0x90);
2451
-
p[351 + i] = dsaf_read_dev(ddev,
2374
+
p[355 + i] = dsaf_read_dev(ddev,
2452
2375
DSAF_XOD_ETS_TOKEN_CFG_0_REG + i * 0x90);
2453
2376
}
2454
2377
2455
-
p[359] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_0_0_REG + port * 0x90);
2456
-
p[360] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_1_0_REG + port * 0x90);
2457
-
p[361] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_2_0_REG + port * 0x90);
2378
+
p[363] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_0_0_REG + port * 0x90);
2379
+
p[364] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_1_0_REG + port * 0x90);
2380
+
p[365] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_2_0_REG + port * 0x90);
2458
2381
2459
2382
for (i = 0; i < DSAF_XOD_BIG_NUM / DSAF_COMM_CHN; i++) {
2460
2383
j = i * DSAF_COMM_CHN + port;
2461
-
p[362 + i] = dsaf_read_dev(ddev,
2384
+
p[366 + i] = dsaf_read_dev(ddev,
2462
2385
DSAF_XOD_GNT_L_0_REG + j * 0x90);
2463
-
p[365 + i] = dsaf_read_dev(ddev,
2386
+
p[369 + i] = dsaf_read_dev(ddev,
2464
2387
DSAF_XOD_GNT_H_0_REG + j * 0x90);
2465
-
p[368 + i] = dsaf_read_dev(ddev,
2388
+
p[372 + i] = dsaf_read_dev(ddev,
2466
2389
DSAF_XOD_CONNECT_STATE_0_REG + j * 0x90);
2467
-
p[371 + i] = dsaf_read_dev(ddev,
2390
+
p[375 + i] = dsaf_read_dev(ddev,
2468
2391
DSAF_XOD_RCVPKT_CNT_0_REG + j * 0x90);
2469
-
p[374 + i] = dsaf_read_dev(ddev,
2392
+
p[378 + i] = dsaf_read_dev(ddev,
2470
2393
DSAF_XOD_RCVTC0_CNT_0_REG + j * 0x90);
2471
-
p[377 + i] = dsaf_read_dev(ddev,
2394
+
p[381 + i] = dsaf_read_dev(ddev,
2472
2395
DSAF_XOD_RCVTC1_CNT_0_REG + j * 0x90);
2473
-
p[380 + i] = dsaf_read_dev(ddev,
2396
+
p[384 + i] = dsaf_read_dev(ddev,
2474
2397
DSAF_XOD_RCVTC2_CNT_0_REG + j * 0x90);
2475
-
p[383 + i] = dsaf_read_dev(ddev,
2398
+
p[387 + i] = dsaf_read_dev(ddev,
2476
2399
DSAF_XOD_RCVTC3_CNT_0_REG + j * 0x90);
2477
-
p[386 + i] = dsaf_read_dev(ddev,
2400
+
p[390 + i] = dsaf_read_dev(ddev,
2478
2401
DSAF_XOD_RCVVC0_CNT_0_REG + j * 0x90);
2479
-
p[389 + i] = dsaf_read_dev(ddev,
2402
+
p[393 + i] = dsaf_read_dev(ddev,
2480
2403
DSAF_XOD_RCVVC1_CNT_0_REG + j * 0x90);
2481
2404
}
2482
2405
2483
-
p[392] = dsaf_read_dev(ddev,
2484
-
DSAF_XOD_XGE_RCVIN0_CNT_0_REG + port * 0x90);
2485
-
p[393] = dsaf_read_dev(ddev,
2486
-
DSAF_XOD_XGE_RCVIN1_CNT_0_REG + port * 0x90);
2487
-
p[394] = dsaf_read_dev(ddev,
2488
-
DSAF_XOD_XGE_RCVIN2_CNT_0_REG + port * 0x90);
2489
-
p[395] = dsaf_read_dev(ddev,
2490
-
DSAF_XOD_XGE_RCVIN3_CNT_0_REG + port * 0x90);
2491
2406
p[396] = dsaf_read_dev(ddev,
2492
-
DSAF_XOD_XGE_RCVIN4_CNT_0_REG + port * 0x90);
2407
+
DSAF_XOD_XGE_RCVIN0_CNT_0_REG + port * 0x90);
2493
2408
p[397] = dsaf_read_dev(ddev,
2494
-
DSAF_XOD_XGE_RCVIN5_CNT_0_REG + port * 0x90);
2409
+
DSAF_XOD_XGE_RCVIN1_CNT_0_REG + port * 0x90);
2495
2410
p[398] = dsaf_read_dev(ddev,
2496
-
DSAF_XOD_XGE_RCVIN6_CNT_0_REG + port * 0x90);
2411
+
DSAF_XOD_XGE_RCVIN2_CNT_0_REG + port * 0x90);
2497
2412
p[399] = dsaf_read_dev(ddev,
2498
-
DSAF_XOD_XGE_RCVIN7_CNT_0_REG + port * 0x90);
2413
+
DSAF_XOD_XGE_RCVIN3_CNT_0_REG + port * 0x90);
2499
2414
p[400] = dsaf_read_dev(ddev,
2500
-
DSAF_XOD_PPE_RCVIN0_CNT_0_REG + port * 0x90);
2415
+
DSAF_XOD_XGE_RCVIN4_CNT_0_REG + port * 0x90);
2501
2416
p[401] = dsaf_read_dev(ddev,
2502
-
DSAF_XOD_PPE_RCVIN1_CNT_0_REG + port * 0x90);
2417
+
DSAF_XOD_XGE_RCVIN5_CNT_0_REG + port * 0x90);
2503
2418
p[402] = dsaf_read_dev(ddev,
2504
-
DSAF_XOD_ROCEE_RCVIN0_CNT_0_REG + port * 0x90);
2419
+
DSAF_XOD_XGE_RCVIN6_CNT_0_REG + port * 0x90);
2505
2420
p[403] = dsaf_read_dev(ddev,
2506
-
DSAF_XOD_ROCEE_RCVIN1_CNT_0_REG + port * 0x90);
2421
+
DSAF_XOD_XGE_RCVIN7_CNT_0_REG + port * 0x90);
2507
2422
p[404] = dsaf_read_dev(ddev,
2423
+
DSAF_XOD_PPE_RCVIN0_CNT_0_REG + port * 0x90);
2424
+
p[405] = dsaf_read_dev(ddev,
2425
+
DSAF_XOD_PPE_RCVIN1_CNT_0_REG + port * 0x90);
2426
+
p[406] = dsaf_read_dev(ddev,
2427
+
DSAF_XOD_ROCEE_RCVIN0_CNT_0_REG + port * 0x90);
2428
+
p[407] = dsaf_read_dev(ddev,
2429
+
DSAF_XOD_ROCEE_RCVIN1_CNT_0_REG + port * 0x90);
2430
+
p[408] = dsaf_read_dev(ddev,
2508
2431
DSAF_XOD_FIFO_STATUS_0_REG + port * 0x90);
2509
2432
2510
2433
/* dsaf voq registers */
2511
2434
for (i = 0; i < DSAF_VOQ_NUM / DSAF_COMM_CHN; i++) {
2512
2435
j = (i * DSAF_COMM_CHN + port) * 0x90;
2513
-
p[405 + i] = dsaf_read_dev(ddev,
2436
+
p[409 + i] = dsaf_read_dev(ddev,
2514
2437
DSAF_VOQ_ECC_INVERT_EN_0_REG + j);
2515
-
p[408 + i] = dsaf_read_dev(ddev,
2438
+
p[412 + i] = dsaf_read_dev(ddev,
2516
2439
DSAF_VOQ_SRAM_PKT_NUM_0_REG + j);
2517
-
p[411 + i] = dsaf_read_dev(ddev, DSAF_VOQ_IN_PKT_NUM_0_REG + j);
2518
-
p[414 + i] = dsaf_read_dev(ddev,
2440
+
p[415 + i] = dsaf_read_dev(ddev, DSAF_VOQ_IN_PKT_NUM_0_REG + j);
2441
+
p[418 + i] = dsaf_read_dev(ddev,
2519
2442
DSAF_VOQ_OUT_PKT_NUM_0_REG + j);
2520
-
p[417 + i] = dsaf_read_dev(ddev,
2443
+
p[421 + i] = dsaf_read_dev(ddev,
2521
2444
DSAF_VOQ_ECC_ERR_ADDR_0_REG + j);
2522
-
p[420 + i] = dsaf_read_dev(ddev, DSAF_VOQ_BP_STATUS_0_REG + j);
2523
-
p[423 + i] = dsaf_read_dev(ddev, DSAF_VOQ_SPUP_IDLE_0_REG + j);
2524
-
p[426 + i] = dsaf_read_dev(ddev,
2445
+
p[424 + i] = dsaf_read_dev(ddev, DSAF_VOQ_BP_STATUS_0_REG + j);
2446
+
p[427 + i] = dsaf_read_dev(ddev, DSAF_VOQ_SPUP_IDLE_0_REG + j);
2447
+
p[430 + i] = dsaf_read_dev(ddev,
2525
2448
DSAF_VOQ_XGE_XOD_REQ_0_0_REG + j);
2526
-
p[429 + i] = dsaf_read_dev(ddev,
2449
+
p[433 + i] = dsaf_read_dev(ddev,
2527
2450
DSAF_VOQ_XGE_XOD_REQ_1_0_REG + j);
2528
-
p[432 + i] = dsaf_read_dev(ddev,
2451
+
p[436 + i] = dsaf_read_dev(ddev,
2529
2452
DSAF_VOQ_PPE_XOD_REQ_0_REG + j);
2530
-
p[435 + i] = dsaf_read_dev(ddev,
2453
+
p[439 + i] = dsaf_read_dev(ddev,
2531
2454
DSAF_VOQ_ROCEE_XOD_REQ_0_REG + j);
2532
-
p[438 + i] = dsaf_read_dev(ddev,
2455
+
p[442 + i] = dsaf_read_dev(ddev,
2533
2456
DSAF_VOQ_BP_ALL_THRD_0_REG + j);
2534
2457
}
2535
2458
2536
2459
/* dsaf tbl registers */
2537
-
p[441] = dsaf_read_dev(ddev, DSAF_TBL_CTRL_0_REG);
2538
-
p[442] = dsaf_read_dev(ddev, DSAF_TBL_INT_MSK_0_REG);
2539
-
p[443] = dsaf_read_dev(ddev, DSAF_TBL_INT_SRC_0_REG);
2540
-
p[444] = dsaf_read_dev(ddev, DSAF_TBL_INT_STS_0_REG);
2541
-
p[445] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_ADDR_0_REG);
2542
-
p[446] = dsaf_read_dev(ddev, DSAF_TBL_LINE_ADDR_0_REG);
2543
-
p[447] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_HIGH_0_REG);
2544
-
p[448] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_LOW_0_REG);
2545
-
p[449] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_4_0_REG);
2546
-
p[450] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_3_0_REG);
2547
-
p[451] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_2_0_REG);
2548
-
p[452] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_1_0_REG);
2549
-
p[453] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_0_0_REG);
2550
-
p[454] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_UCAST_CFG_0_REG);
2551
-
p[455] = dsaf_read_dev(ddev, DSAF_TBL_LIN_CFG_0_REG);
2552
-
p[456] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RDATA_HIGH_0_REG);
2553
-
p[457] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RDATA_LOW_0_REG);
2554
-
p[458] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA4_0_REG);
2555
-
p[459] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA3_0_REG);
2556
-
p[460] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA2_0_REG);
2557
-
p[461] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA1_0_REG);
2558
-
p[462] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA0_0_REG);
2559
-
p[463] = dsaf_read_dev(ddev, DSAF_TBL_LIN_RDATA_0_REG);
2460
+
p[445] = dsaf_read_dev(ddev, DSAF_TBL_CTRL_0_REG);
2461
+
p[446] = dsaf_read_dev(ddev, DSAF_TBL_INT_MSK_0_REG);
2462
+
p[447] = dsaf_read_dev(ddev, DSAF_TBL_INT_SRC_0_REG);
2463
+
p[448] = dsaf_read_dev(ddev, DSAF_TBL_INT_STS_0_REG);
2464
+
p[449] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_ADDR_0_REG);
2465
+
p[450] = dsaf_read_dev(ddev, DSAF_TBL_LINE_ADDR_0_REG);
2466
+
p[451] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_HIGH_0_REG);
2467
+
p[452] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_LOW_0_REG);
2468
+
p[453] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_4_0_REG);
2469
+
p[454] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_3_0_REG);
2470
+
p[455] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_2_0_REG);
2471
+
p[456] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_1_0_REG);
2472
+
p[457] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_0_0_REG);
2473
+
p[458] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_UCAST_CFG_0_REG);
2474
+
p[459] = dsaf_read_dev(ddev, DSAF_TBL_LIN_CFG_0_REG);
2475
+
p[460] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RDATA_HIGH_0_REG);
2476
+
p[461] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RDATA_LOW_0_REG);
2477
+
p[462] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA4_0_REG);
2478
+
p[463] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA3_0_REG);
2479
+
p[464] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA2_0_REG);
2480
+
p[465] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA1_0_REG);
2481
+
p[466] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA0_0_REG);
2482
+
p[467] = dsaf_read_dev(ddev, DSAF_TBL_LIN_RDATA_0_REG);
2560
2483
2561
2484
for (i = 0; i < DSAF_SW_PORT_NUM; i++) {
2562
2485
j = i * 0x8;
2563
-
p[464 + 2 * i] = dsaf_read_dev(ddev,
2486
+
p[468 + 2 * i] = dsaf_read_dev(ddev,
2564
2487
DSAF_TBL_DA0_MIS_INFO1_0_REG + j);
2565
-
p[465 + 2 * i] = dsaf_read_dev(ddev,
2488
+
p[469 + 2 * i] = dsaf_read_dev(ddev,
2566
2489
DSAF_TBL_DA0_MIS_INFO0_0_REG + j);
2567
2490
}
2568
2491
2569
-
p[480] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO2_0_REG);
2570
-
p[481] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO1_0_REG);
2571
-
p[482] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO0_0_REG);
2572
-
p[483] = dsaf_read_dev(ddev, DSAF_TBL_PUL_0_REG);
2573
-
p[484] = dsaf_read_dev(ddev, DSAF_TBL_OLD_RSLT_0_REG);
2574
-
p[485] = dsaf_read_dev(ddev, DSAF_TBL_OLD_SCAN_VAL_0_REG);
2575
-
p[486] = dsaf_read_dev(ddev, DSAF_TBL_DFX_CTRL_0_REG);
2576
-
p[487] = dsaf_read_dev(ddev, DSAF_TBL_DFX_STAT_0_REG);
2577
-
p[488] = dsaf_read_dev(ddev, DSAF_TBL_DFX_STAT_2_0_REG);
2578
-
p[489] = dsaf_read_dev(ddev, DSAF_TBL_LKUP_NUM_I_0_REG);
2579
-
p[490] = dsaf_read_dev(ddev, DSAF_TBL_LKUP_NUM_O_0_REG);
2580
-
p[491] = dsaf_read_dev(ddev, DSAF_TBL_UCAST_BCAST_MIS_INFO_0_0_REG);
2492
+
p[484] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO2_0_REG);
2493
+
p[485] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO1_0_REG);
2494
+
p[486] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO0_0_REG);
2495
+
p[487] = dsaf_read_dev(ddev, DSAF_TBL_PUL_0_REG);
2496
+
p[488] = dsaf_read_dev(ddev, DSAF_TBL_OLD_RSLT_0_REG);
2497
+
p[489] = dsaf_read_dev(ddev, DSAF_TBL_OLD_SCAN_VAL_0_REG);
2498
+
p[490] = dsaf_read_dev(ddev, DSAF_TBL_DFX_CTRL_0_REG);
2499
+
p[491] = dsaf_read_dev(ddev, DSAF_TBL_DFX_STAT_0_REG);
2500
+
p[492] = dsaf_read_dev(ddev, DSAF_TBL_DFX_STAT_2_0_REG);
2501
+
p[493] = dsaf_read_dev(ddev, DSAF_TBL_LKUP_NUM_I_0_REG);
2502
+
p[494] = dsaf_read_dev(ddev, DSAF_TBL_LKUP_NUM_O_0_REG);
2503
+
p[495] = dsaf_read_dev(ddev, DSAF_TBL_UCAST_BCAST_MIS_INFO_0_0_REG);
2581
2504
2582
2505
/* dsaf other registers */
2583
-
p[492] = dsaf_read_dev(ddev, DSAF_INODE_FIFO_WL_0_REG + port * 0x4);
2584
-
p[493] = dsaf_read_dev(ddev, DSAF_ONODE_FIFO_WL_0_REG + port * 0x4);
2585
-
p[494] = dsaf_read_dev(ddev, DSAF_XGE_GE_WORK_MODE_0_REG + port * 0x4);
2586
-
p[495] = dsaf_read_dev(ddev,
2506
+
p[496] = dsaf_read_dev(ddev, DSAF_INODE_FIFO_WL_0_REG + port * 0x4);
2507
+
p[497] = dsaf_read_dev(ddev, DSAF_ONODE_FIFO_WL_0_REG + port * 0x4);
2508
+
p[498] = dsaf_read_dev(ddev, DSAF_XGE_GE_WORK_MODE_0_REG + port * 0x4);
2509
+
p[499] = dsaf_read_dev(ddev,
2587
2510
DSAF_XGE_APP_RX_LINK_UP_0_REG + port * 0x4);
2588
-
p[496] = dsaf_read_dev(ddev, DSAF_NETPORT_CTRL_SIG_0_REG + port * 0x4);
2589
-
p[497] = dsaf_read_dev(ddev, DSAF_XGE_CTRL_SIG_CFG_0_REG + port * 0x4);
2511
+
p[500] = dsaf_read_dev(ddev, DSAF_NETPORT_CTRL_SIG_0_REG + port * 0x4);
2512
+
p[501] = dsaf_read_dev(ddev, DSAF_XGE_CTRL_SIG_CFG_0_REG + port * 0x4);
2590
2513
2591
2514
if (!is_ver1)
2592
-
p[498] = dsaf_read_dev(ddev, DSAF_PAUSE_CFG_REG + port * 0x4);
2515
+
p[502] = dsaf_read_dev(ddev, DSAF_PAUSE_CFG_REG + port * 0x4);
2593
2516
2594
2517
/* mark end of dsaf regs */
2595
-
for (i = 499; i < 504; i++)
2518
+
for (i = 503; i < 504; i++)
2596
2519
p[i] = 0xdddddddd;
2597
2520
}
2598
2521
···
2750
2673
return DSAF_DUMP_REGS_NUM;
2751
2674
}
2752
2675
2676
+
static void set_promisc_tcam_enable(struct dsaf_device *dsaf_dev, u32 port)
2677
+
{
2678
+
struct dsaf_tbl_tcam_ucast_cfg tbl_tcam_ucast = {0, 1, 0, 0, 0x80};
2679
+
struct dsaf_tbl_tcam_data tbl_tcam_data_mc = {0x01000000, port};
2680
+
struct dsaf_tbl_tcam_data tbl_tcam_mask_uc = {0x01000000, 0xf};
2681
+
struct dsaf_tbl_tcam_mcast_cfg tbl_tcam_mcast = {0, 0, {0} };
2682
+
struct dsaf_drv_priv *priv = hns_dsaf_dev_priv(dsaf_dev);
2683
+
struct dsaf_tbl_tcam_data tbl_tcam_data_uc = {0, port};
2684
+
struct dsaf_drv_mac_single_dest_entry mask_entry;
2685
+
struct dsaf_drv_tbl_tcam_key temp_key, mask_key;
2686
+
struct dsaf_drv_soft_mac_tbl *soft_mac_entry;
2687
+
u16 entry_index = DSAF_INVALID_ENTRY_IDX;
2688
+
struct dsaf_drv_tbl_tcam_key mac_key;
2689
+
struct hns_mac_cb *mac_cb;
2690
+
u8 addr[ETH_ALEN] = {0};
2691
+
u8 port_num;
2692
+
u16 mskid;
2693
+
2694
+
/* promisc use vague table match with vlanid = 0 & macaddr = 0 */
2695
+
hns_dsaf_set_mac_key(dsaf_dev, &mac_key, 0x00, port, addr);
2696
+
entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
2697
+
if (entry_index != DSAF_INVALID_ENTRY_IDX)
2698
+
return;
2699
+
2700
+
/* put promisc tcam entry in the end. */
2701
+
/* 1. set promisc unicast vague tcam entry. */
2702
+
entry_index = hns_dsaf_find_empty_mac_entry_reverse(dsaf_dev);
2703
+
if (entry_index == DSAF_INVALID_ENTRY_IDX) {
2704
+
dev_err(dsaf_dev->dev,
2705
+
"enable uc promisc failed (port:%#x)\n",
2706
+
port);
2707
+
return;
2708
+
}
2709
+
2710
+
mac_cb = dsaf_dev->mac_cb[port];
2711
+
(void)hns_mac_get_inner_port_num(mac_cb, 0, &port_num);
2712
+
tbl_tcam_ucast.tbl_ucast_out_port = port_num;
2713
+
2714
+
/* config uc vague table */
2715
+
hns_dsaf_tcam_uc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_uc,
2716
+
&tbl_tcam_mask_uc, &tbl_tcam_ucast);
2717
+
2718
+
/* update software entry */
2719
+
soft_mac_entry = priv->soft_mac_tbl;
2720
+
soft_mac_entry += entry_index;
2721
+
soft_mac_entry->index = entry_index;
2722
+
soft_mac_entry->tcam_key.high.val = mac_key.high.val;
2723
+
soft_mac_entry->tcam_key.low.val = mac_key.low.val;
2724
+
/* step back to the START for mc. */
2725
+
soft_mac_entry = priv->soft_mac_tbl;
2726
+
2727
+
/* 2. set promisc multicast vague tcam entry. */
2728
+
entry_index = hns_dsaf_find_empty_mac_entry_reverse(dsaf_dev);
2729
+
if (entry_index == DSAF_INVALID_ENTRY_IDX) {
2730
+
dev_err(dsaf_dev->dev,
2731
+
"enable mc promisc failed (port:%#x)\n",
2732
+
port);
2733
+
return;
2734
+
}
2735
+
2736
+
memset(&mask_entry, 0x0, sizeof(mask_entry));
2737
+
memset(&mask_key, 0x0, sizeof(mask_key));
2738
+
memset(&temp_key, 0x0, sizeof(temp_key));
2739
+
mask_entry.addr[0] = 0x01;
2740
+
hns_dsaf_set_mac_key(dsaf_dev, &mask_key, mask_entry.in_vlan_id,
2741
+
port, mask_entry.addr);
2742
+
tbl_tcam_mcast.tbl_mcast_item_vld = 1;
2743
+
tbl_tcam_mcast.tbl_mcast_old_en = 0;
2744
+
2745
+
if (port < DSAF_SERVICE_NW_NUM) {
2746
+
mskid = port;
2747
+
} else if (port >= DSAF_BASE_INNER_PORT_NUM) {
2748
+
mskid = port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM;
2749
+
} else {
2750
+
dev_err(dsaf_dev->dev, "%s,pnum(%d)error,key(%#x:%#x)\n",
2751
+
dsaf_dev->ae_dev.name, port,
2752
+
mask_key.high.val, mask_key.low.val);
2753
+
return;
2754
+
}
2755
+
2756
+
dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32],
2757
+
mskid % 32, 1);
2758
+
memcpy(&temp_key, &mask_key, sizeof(mask_key));
2759
+
hns_dsaf_tcam_mc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_mc,
2760
+
(struct dsaf_tbl_tcam_data *)(&mask_key),
2761
+
&tbl_tcam_mcast);
2762
+
2763
+
/* update software entry */
2764
+
soft_mac_entry += entry_index;
2765
+
soft_mac_entry->index = entry_index;
2766
+
soft_mac_entry->tcam_key.high.val = temp_key.high.val;
2767
+
soft_mac_entry->tcam_key.low.val = temp_key.low.val;
2768
+
}
2769
+
2770
+
static void set_promisc_tcam_disable(struct dsaf_device *dsaf_dev, u32 port)
2771
+
{
2772
+
struct dsaf_tbl_tcam_data tbl_tcam_data_mc = {0x01000000, port};
2773
+
struct dsaf_tbl_tcam_ucast_cfg tbl_tcam_ucast = {0, 0, 0, 0, 0};
2774
+
struct dsaf_tbl_tcam_mcast_cfg tbl_tcam_mcast = {0, 0, {0} };
2775
+
struct dsaf_drv_priv *priv = hns_dsaf_dev_priv(dsaf_dev);
2776
+
struct dsaf_tbl_tcam_data tbl_tcam_data_uc = {0, 0};
2777
+
struct dsaf_tbl_tcam_data tbl_tcam_mask = {0, 0};
2778
+
struct dsaf_drv_soft_mac_tbl *soft_mac_entry;
2779
+
u16 entry_index = DSAF_INVALID_ENTRY_IDX;
2780
+
struct dsaf_drv_tbl_tcam_key mac_key;
2781
+
u8 addr[ETH_ALEN] = {0};
2782
+
2783
+
/* 1. delete uc vague tcam entry. */
2784
+
/* promisc use vague table match with vlanid = 0 & macaddr = 0 */
2785
+
hns_dsaf_set_mac_key(dsaf_dev, &mac_key, 0x00, port, addr);
2786
+
entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
2787
+
2788
+
if (entry_index == DSAF_INVALID_ENTRY_IDX)
2789
+
return;
2790
+
2791
+
/* config uc vague table */
2792
+
hns_dsaf_tcam_uc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_uc,
2793
+
&tbl_tcam_mask, &tbl_tcam_ucast);
2794
+
/* update soft management table. */
2795
+
soft_mac_entry = priv->soft_mac_tbl;
2796
+
soft_mac_entry += entry_index;
2797
+
soft_mac_entry->index = DSAF_INVALID_ENTRY_IDX;
2798
+
/* step back to the START for mc. */
2799
+
soft_mac_entry = priv->soft_mac_tbl;
2800
+
2801
+
/* 2. delete mc vague tcam entry. */
2802
+
addr[0] = 0x01;
2803
+
memset(&mac_key, 0x0, sizeof(mac_key));
2804
+
hns_dsaf_set_mac_key(dsaf_dev, &mac_key, 0x00, port, addr);
2805
+
entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
2806
+
2807
+
if (entry_index == DSAF_INVALID_ENTRY_IDX)
2808
+
return;
2809
+
2810
+
/* config mc vague table */
2811
+
hns_dsaf_tcam_mc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_mc,
2812
+
&tbl_tcam_mask, &tbl_tcam_mcast);
2813
+
/* update soft management table. */
2814
+
soft_mac_entry += entry_index;
2815
+
soft_mac_entry->index = DSAF_INVALID_ENTRY_IDX;
2816
+
}
2817
+
2753
2818
/* Reserve the last TCAM entry for promisc support */
2754
-
#define dsaf_promisc_tcam_entry(port) \
2755
-
(DSAF_TCAM_SUM - DSAFV2_MAC_FUZZY_TCAM_NUM + (port))
2756
2819
void hns_dsaf_set_promisc_tcam(struct dsaf_device *dsaf_dev,
2757
2820
u32 port, bool enable)
2758
2821
{
2759
-
struct dsaf_drv_priv *priv = hns_dsaf_dev_priv(dsaf_dev);
2760
-
struct dsaf_drv_soft_mac_tbl *soft_mac_entry = priv->soft_mac_tbl;
2761
-
u16 entry_index;
2762
-
struct dsaf_drv_tbl_tcam_key tbl_tcam_data, tbl_tcam_mask;
2763
-
struct dsaf_tbl_tcam_mcast_cfg mac_data = {0};
2764
-
2765
-
if ((AE_IS_VER1(dsaf_dev->dsaf_ver)) || HNS_DSAF_IS_DEBUG(dsaf_dev))
2766
-
return;
2767
-
2768
-
/* find the tcam entry index for promisc */
2769
-
entry_index = dsaf_promisc_tcam_entry(port);
2770
-
2771
-
memset(&tbl_tcam_data, 0, sizeof(tbl_tcam_data));
2772
-
memset(&tbl_tcam_mask, 0, sizeof(tbl_tcam_mask));
2773
-
2774
-
/* config key mask */
2775
-
if (enable) {
2776
-
dsaf_set_field(tbl_tcam_data.low.bits.port_vlan,
2777
-
DSAF_TBL_TCAM_KEY_PORT_M,
2778
-
DSAF_TBL_TCAM_KEY_PORT_S, port);
2779
-
dsaf_set_field(tbl_tcam_mask.low.bits.port_vlan,
2780
-
DSAF_TBL_TCAM_KEY_PORT_M,
2781
-
DSAF_TBL_TCAM_KEY_PORT_S, 0xf);
2782
-
2783
-
/* SUB_QID */
2784
-
dsaf_set_bit(mac_data.tbl_mcast_port_msk[0],
2785
-
DSAF_SERVICE_NW_NUM, true);
2786
-
mac_data.tbl_mcast_item_vld = true; /* item_vld bit */
2787
-
} else {
2788
-
mac_data.tbl_mcast_item_vld = false; /* item_vld bit */
2789
-
}
2790
-
2791
-
dev_dbg(dsaf_dev->dev,
2792
-
"set_promisc_entry, %s Mac key(%#x:%#x) entry_index%d\n",
2793
-
dsaf_dev->ae_dev.name, tbl_tcam_data.high.val,
2794
-
tbl_tcam_data.low.val, entry_index);
2795
-
2796
-
/* config promisc entry with mask */
2797
-
hns_dsaf_tcam_mc_cfg(dsaf_dev, entry_index,
2798
-
(struct dsaf_tbl_tcam_data *)&tbl_tcam_data,
2799
-
(struct dsaf_tbl_tcam_data *)&tbl_tcam_mask,
2800
-
&mac_data);
2801
-
2802
-
/* config software entry */
2803
-
soft_mac_entry += entry_index;
2804
-
soft_mac_entry->index = enable ? entry_index : DSAF_INVALID_ENTRY_IDX;
2822
+
if (enable)
2823
+
set_promisc_tcam_enable(dsaf_dev, port);
2824
+
else
2825
+
set_promisc_tcam_disable(dsaf_dev, port);
2805
2826
}
2806
2827
2807
2828
int hns_dsaf_wait_pkt_clean(struct dsaf_device *dsaf_dev, int port)
+7
-6
drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
+7
-6
drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
···
176
176
#define DSAF_INODE_IN_DATA_STP_DISC_0_REG 0x1A50
177
177
#define DSAF_INODE_GE_FC_EN_0_REG 0x1B00
178
178
#define DSAF_INODE_VC0_IN_PKT_NUM_0_REG 0x1B50
179
-
#define DSAF_INODE_VC1_IN_PKT_NUM_0_REG 0x1C00
179
+
#define DSAF_INODE_VC1_IN_PKT_NUM_0_REG 0x103C
180
180
#define DSAF_INODE_IN_PRIO_PAUSE_BASE_REG 0x1C00
181
181
#define DSAF_INODE_IN_PRIO_PAUSE_BASE_OFFSET 0x100
182
182
#define DSAF_INODE_IN_PRIO_PAUSE_OFFSET 0x50
···
404
404
#define RCB_ECC_ERR_ADDR4_REG 0x460
405
405
#define RCB_ECC_ERR_ADDR5_REG 0x464
406
406
407
-
#define RCB_COM_SF_CFG_INTMASK_RING 0x480
408
-
#define RCB_COM_SF_CFG_RING_STS 0x484
409
-
#define RCB_COM_SF_CFG_RING 0x488
410
-
#define RCB_COM_SF_CFG_INTMASK_BD 0x48C
411
-
#define RCB_COM_SF_CFG_BD_RINT_STS 0x470
407
+
#define RCB_COM_SF_CFG_INTMASK_RING 0x470
408
+
#define RCB_COM_SF_CFG_RING_STS 0x474
409
+
#define RCB_COM_SF_CFG_RING 0x478
410
+
#define RCB_COM_SF_CFG_INTMASK_BD 0x47C
411
+
#define RCB_COM_SF_CFG_BD_RINT_STS 0x480
412
412
#define RCB_COM_RCB_RD_BD_BUSY 0x490
413
413
#define RCB_COM_RCB_FBD_CRT_EN 0x494
414
414
#define RCB_COM_AXI_WR_ERR_INTMASK 0x498
···
534
534
#define GMAC_LD_LINK_COUNTER_REG 0x01D0UL
535
535
#define GMAC_LOOP_REG 0x01DCUL
536
536
#define GMAC_RECV_CONTROL_REG 0x01E0UL
537
+
#define GMAC_PCS_RX_EN_REG 0x01E4UL
537
538
#define GMAC_VLAN_CODE_REG 0x01E8UL
538
539
#define GMAC_RX_OVERRUN_CNT_REG 0x01ECUL
539
540
#define GMAC_RX_LENGTHFIELD_ERR_CNT_REG 0x01F4UL
+39
-4
drivers/net/ethernet/hisilicon/hns/hns_enet.c
+39
-4
drivers/net/ethernet/hisilicon/hns/hns_enet.c
···
1186
1186
if (h->phy_if == PHY_INTERFACE_MODE_XGMII)
1187
1187
phy_dev->autoneg = false;
1188
1188
1189
+
if (h->phy_if == PHY_INTERFACE_MODE_SGMII)
1190
+
phy_stop(phy_dev);
1191
+
1189
1192
return 0;
1190
1193
}
1191
1194
···
1284
1281
return cpu;
1285
1282
}
1286
1283
1284
+
static void hns_nic_free_irq(int q_num, struct hns_nic_priv *priv)
1285
+
{
1286
+
int i;
1287
+
1288
+
for (i = 0; i < q_num * 2; i++) {
1289
+
if (priv->ring_data[i].ring->irq_init_flag == RCB_IRQ_INITED) {
1290
+
irq_set_affinity_hint(priv->ring_data[i].ring->irq,
1291
+
NULL);
1292
+
free_irq(priv->ring_data[i].ring->irq,
1293
+
&priv->ring_data[i]);
1294
+
priv->ring_data[i].ring->irq_init_flag =
1295
+
RCB_IRQ_NOT_INITED;
1296
+
}
1297
+
}
1298
+
}
1299
+
1287
1300
static int hns_nic_init_irq(struct hns_nic_priv *priv)
1288
1301
{
1289
1302
struct hnae_handle *h = priv->ae_handle;
···
1325
1306
if (ret) {
1326
1307
netdev_err(priv->netdev, "request irq(%d) fail\n",
1327
1308
rd->ring->irq);
1328
-
return ret;
1309
+
goto out_free_irq;
1329
1310
}
1330
1311
disable_irq(rd->ring->irq);
1331
1312
···
1340
1321
}
1341
1322
1342
1323
return 0;
1324
+
1325
+
out_free_irq:
1326
+
hns_nic_free_irq(h->q_num, priv);
1327
+
return ret;
1343
1328
}
1344
1329
1345
1330
static int hns_nic_net_up(struct net_device *ndev)
···
1352
1329
struct hnae_handle *h = priv->ae_handle;
1353
1330
int i, j;
1354
1331
int ret;
1332
+
1333
+
if (!test_bit(NIC_STATE_DOWN, &priv->state))
1334
+
return 0;
1355
1335
1356
1336
ret = hns_nic_init_irq(priv);
1357
1337
if (ret != 0) {
···
1391
1365
for (j = i - 1; j >= 0; j--)
1392
1366
hns_nic_ring_close(ndev, j);
1393
1367
1368
+
hns_nic_free_irq(h->q_num, priv);
1394
1369
set_bit(NIC_STATE_DOWN, &priv->state);
1395
1370
1396
1371
return ret;
···
1509
1482
}
1510
1483
1511
1484
static void hns_tx_timeout_reset(struct hns_nic_priv *priv);
1485
+
#define HNS_TX_TIMEO_LIMIT (40 * HZ)
1512
1486
static void hns_nic_net_timeout(struct net_device *ndev)
1513
1487
{
1514
1488
struct hns_nic_priv *priv = netdev_priv(ndev);
1515
1489
1516
-
hns_tx_timeout_reset(priv);
1490
+
if (ndev->watchdog_timeo < HNS_TX_TIMEO_LIMIT) {
1491
+
ndev->watchdog_timeo *= 2;
1492
+
netdev_info(ndev, "watchdog_timo changed to %d.\n",
1493
+
ndev->watchdog_timeo);
1494
+
} else {
1495
+
ndev->watchdog_timeo = HNS_NIC_TX_TIMEOUT;
1496
+
hns_tx_timeout_reset(priv);
1497
+
}
1517
1498
}
1518
1499
1519
1500
static int hns_nic_do_ioctl(struct net_device *netdev, struct ifreq *ifr,
···
2084
2049
= container_of(work, struct hns_nic_priv, service_task);
2085
2050
struct hnae_handle *h = priv->ae_handle;
2086
2051
2052
+
hns_nic_reset_subtask(priv);
2087
2053
hns_nic_update_link_status(priv->netdev);
2088
2054
h->dev->ops->update_led_status(h);
2089
2055
hns_nic_update_stats(priv->netdev);
2090
2056
2091
-
hns_nic_reset_subtask(priv);
2092
2057
hns_nic_service_event_complete(priv);
2093
2058
}
2094
2059
···
2374
2339
ndev->min_mtu = MAC_MIN_MTU;
2375
2340
switch (priv->enet_ver) {
2376
2341
case AE_VERSION_2:
2377
-
ndev->features |= NETIF_F_TSO | NETIF_F_TSO6;
2342
+
ndev->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_NTUPLE;
2378
2343
ndev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2379
2344
NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO |
2380
2345
NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6;
+10
-8
drivers/net/ethernet/ibm/ibmvnic.c
+10
-8
drivers/net/ethernet/ibm/ibmvnic.c
···
1939
1939
static struct ibmvnic_rwi *get_next_rwi(struct ibmvnic_adapter *adapter)
1940
1940
{
1941
1941
struct ibmvnic_rwi *rwi;
1942
+
unsigned long flags;
1942
1943
1943
-
mutex_lock(&adapter->rwi_lock);
1944
+
spin_lock_irqsave(&adapter->rwi_lock, flags);
1944
1945
1945
1946
if (!list_empty(&adapter->rwi_list)) {
1946
1947
rwi = list_first_entry(&adapter->rwi_list, struct ibmvnic_rwi,
···
1951
1950
rwi = NULL;
1952
1951
}
1953
1952
1954
-
mutex_unlock(&adapter->rwi_lock);
1953
+
spin_unlock_irqrestore(&adapter->rwi_lock, flags);
1955
1954
return rwi;
1956
1955
}
1957
1956
···
2026
2025
struct list_head *entry, *tmp_entry;
2027
2026
struct ibmvnic_rwi *rwi, *tmp;
2028
2027
struct net_device *netdev = adapter->netdev;
2028
+
unsigned long flags;
2029
2029
int ret;
2030
2030
2031
2031
if (adapter->state == VNIC_REMOVING ||
···
2043
2041
goto err;
2044
2042
}
2045
2043
2046
-
mutex_lock(&adapter->rwi_lock);
2044
+
spin_lock_irqsave(&adapter->rwi_lock, flags);
2047
2045
2048
2046
list_for_each(entry, &adapter->rwi_list) {
2049
2047
tmp = list_entry(entry, struct ibmvnic_rwi, list);
2050
2048
if (tmp->reset_reason == reason) {
2051
2049
netdev_dbg(netdev, "Skipping matching reset\n");
2052
-
mutex_unlock(&adapter->rwi_lock);
2050
+
spin_unlock_irqrestore(&adapter->rwi_lock, flags);
2053
2051
ret = EBUSY;
2054
2052
goto err;
2055
2053
}
2056
2054
}
2057
2055
2058
-
rwi = kzalloc(sizeof(*rwi), GFP_KERNEL);
2056
+
rwi = kzalloc(sizeof(*rwi), GFP_ATOMIC);
2059
2057
if (!rwi) {
2060
-
mutex_unlock(&adapter->rwi_lock);
2058
+
spin_unlock_irqrestore(&adapter->rwi_lock, flags);
2061
2059
ibmvnic_close(netdev);
2062
2060
ret = ENOMEM;
2063
2061
goto err;
···
2071
2069
}
2072
2070
rwi->reset_reason = reason;
2073
2071
list_add_tail(&rwi->list, &adapter->rwi_list);
2074
-
mutex_unlock(&adapter->rwi_lock);
2072
+
spin_unlock_irqrestore(&adapter->rwi_lock, flags);
2075
2073
adapter->resetting = true;
2076
2074
netdev_dbg(adapter->netdev, "Scheduling reset (reason %d)\n", reason);
2077
2075
schedule_work(&adapter->ibmvnic_reset);
···
4761
4759
4762
4760
INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset);
4763
4761
INIT_LIST_HEAD(&adapter->rwi_list);
4764
-
mutex_init(&adapter->rwi_lock);
4762
+
spin_lock_init(&adapter->rwi_lock);
4765
4763
adapter->resetting = false;
4766
4764
4767
4765
adapter->mac_change_pending = false;
+1
-1
drivers/net/ethernet/ibm/ibmvnic.h
+1
-1
drivers/net/ethernet/ibm/ibmvnic.h
+7
-7
drivers/net/ethernet/intel/i40e/i40e_main.c
+7
-7
drivers/net/ethernet/intel/i40e/i40e_main.c
···
1543
1543
netdev_info(netdev, "set new mac address %pM\n", addr->sa_data);
1544
1544
1545
1545
/* Copy the address first, so that we avoid a possible race with
1546
-
* .set_rx_mode(). If we copy after changing the address in the filter
1547
-
* list, we might open ourselves to a narrow race window where
1548
-
* .set_rx_mode could delete our dev_addr filter and prevent traffic
1549
-
* from passing.
1546
+
* .set_rx_mode().
1547
+
* - Remove old address from MAC filter
1548
+
* - Copy new address
1549
+
* - Add new address to MAC filter
1550
1550
*/
1551
-
ether_addr_copy(netdev->dev_addr, addr->sa_data);
1552
-
1553
1551
spin_lock_bh(&vsi->mac_filter_hash_lock);
1554
1552
i40e_del_mac_filter(vsi, netdev->dev_addr);
1555
-
i40e_add_mac_filter(vsi, addr->sa_data);
1553
+
ether_addr_copy(netdev->dev_addr, addr->sa_data);
1554
+
i40e_add_mac_filter(vsi, netdev->dev_addr);
1556
1555
spin_unlock_bh(&vsi->mac_filter_hash_lock);
1556
+
1557
1557
if (vsi->type == I40E_VSI_MAIN) {
1558
1558
i40e_status ret;
1559
1559
+12
-31
drivers/net/ethernet/intel/i40e/i40e_txrx.c
+12
-31
drivers/net/ethernet/intel/i40e/i40e_txrx.c
···
1559
1559
}
1560
1560
1561
1561
/**
1562
-
* i40e_receive_skb - Send a completed packet up the stack
1563
-
* @rx_ring: rx ring in play
1564
-
* @skb: packet to send up
1565
-
* @vlan_tag: vlan tag for packet
1566
-
**/
1567
-
void i40e_receive_skb(struct i40e_ring *rx_ring,
1568
-
struct sk_buff *skb, u16 vlan_tag)
1569
-
{
1570
-
struct i40e_q_vector *q_vector = rx_ring->q_vector;
1571
-
1572
-
if ((rx_ring->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) &&
1573
-
(vlan_tag & VLAN_VID_MASK))
1574
-
__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
1575
-
1576
-
napi_gro_receive(&q_vector->napi, skb);
1577
-
}
1578
-
1579
-
/**
1580
1562
* i40e_alloc_rx_buffers - Replace used receive buffers
1581
1563
* @rx_ring: ring to place buffers on
1582
1564
* @cleaned_count: number of buffers to replace
···
1775
1793
* other fields within the skb.
1776
1794
**/
1777
1795
void i40e_process_skb_fields(struct i40e_ring *rx_ring,
1778
-
union i40e_rx_desc *rx_desc, struct sk_buff *skb,
1779
-
u8 rx_ptype)
1796
+
union i40e_rx_desc *rx_desc, struct sk_buff *skb)
1780
1797
{
1781
1798
u64 qword = le64_to_cpu(rx_desc->wb.qword1.status_error_len);
1782
1799
u32 rx_status = (qword & I40E_RXD_QW1_STATUS_MASK) >>
···
1783
1802
u32 tsynvalid = rx_status & I40E_RXD_QW1_STATUS_TSYNVALID_MASK;
1784
1803
u32 tsyn = (rx_status & I40E_RXD_QW1_STATUS_TSYNINDX_MASK) >>
1785
1804
I40E_RXD_QW1_STATUS_TSYNINDX_SHIFT;
1805
+
u8 rx_ptype = (qword & I40E_RXD_QW1_PTYPE_MASK) >>
1806
+
I40E_RXD_QW1_PTYPE_SHIFT;
1786
1807
1787
1808
if (unlikely(tsynvalid))
1788
1809
i40e_ptp_rx_hwtstamp(rx_ring->vsi->back, skb, tsyn);
···
1794
1811
i40e_rx_checksum(rx_ring->vsi, skb, rx_desc);
1795
1812
1796
1813
skb_record_rx_queue(skb, rx_ring->queue_index);
1814
+
1815
+
if (qword & BIT(I40E_RX_DESC_STATUS_L2TAG1P_SHIFT)) {
1816
+
u16 vlan_tag = rx_desc->wb.qword0.lo_dword.l2tag1;
1817
+
1818
+
__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
1819
+
le16_to_cpu(vlan_tag));
1820
+
}
1797
1821
1798
1822
/* modifies the skb - consumes the enet header */
1799
1823
skb->protocol = eth_type_trans(skb, rx_ring->netdev);
···
2340
2350
struct i40e_rx_buffer *rx_buffer;
2341
2351
union i40e_rx_desc *rx_desc;
2342
2352
unsigned int size;
2343
-
u16 vlan_tag;
2344
-
u8 rx_ptype;
2345
2353
u64 qword;
2346
2354
2347
2355
/* return some buffers to hardware, one at a time is too slow */
···
2432
2444
/* probably a little skewed due to removing CRC */
2433
2445
total_rx_bytes += skb->len;
2434
2446
2435
-
qword = le64_to_cpu(rx_desc->wb.qword1.status_error_len);
2436
-
rx_ptype = (qword & I40E_RXD_QW1_PTYPE_MASK) >>
2437
-
I40E_RXD_QW1_PTYPE_SHIFT;
2438
-
2439
2447
/* populate checksum, VLAN, and protocol */
2440
-
i40e_process_skb_fields(rx_ring, rx_desc, skb, rx_ptype);
2441
-
2442
-
vlan_tag = (qword & BIT(I40E_RX_DESC_STATUS_L2TAG1P_SHIFT)) ?
2443
-
le16_to_cpu(rx_desc->wb.qword0.lo_dword.l2tag1) : 0;
2448
+
i40e_process_skb_fields(rx_ring, rx_desc, skb);
2444
2449
2445
2450
i40e_trace(clean_rx_irq_rx, rx_ring, rx_desc, skb);
2446
-
i40e_receive_skb(rx_ring, skb, vlan_tag);
2451
+
napi_gro_receive(&rx_ring->q_vector->napi, skb);
2447
2452
skb = NULL;
2448
2453
2449
2454
/* update budget accounting */
+1
-4
drivers/net/ethernet/intel/i40e/i40e_txrx_common.h
+1
-4
drivers/net/ethernet/intel/i40e/i40e_txrx_common.h
···
12
12
union i40e_rx_desc *rx_desc,
13
13
u64 qw);
14
14
void i40e_process_skb_fields(struct i40e_ring *rx_ring,
15
-
union i40e_rx_desc *rx_desc, struct sk_buff *skb,
16
-
u8 rx_ptype);
17
-
void i40e_receive_skb(struct i40e_ring *rx_ring,
18
-
struct sk_buff *skb, u16 vlan_tag);
15
+
union i40e_rx_desc *rx_desc, struct sk_buff *skb);
19
16
void i40e_xdp_ring_update_tail(struct i40e_ring *xdp_ring);
20
17
void i40e_update_rx_stats(struct i40e_ring *rx_ring,
21
18
unsigned int total_rx_bytes,
+2
-10
drivers/net/ethernet/intel/i40e/i40e_xsk.c
+2
-10
drivers/net/ethernet/intel/i40e/i40e_xsk.c
···
634
634
struct i40e_rx_buffer *bi;
635
635
union i40e_rx_desc *rx_desc;
636
636
unsigned int size;
637
-
u16 vlan_tag;
638
-
u8 rx_ptype;
639
637
u64 qword;
640
638
641
639
if (cleaned_count >= I40E_RX_BUFFER_WRITE) {
···
711
713
total_rx_bytes += skb->len;
712
714
total_rx_packets++;
713
715
714
-
qword = le64_to_cpu(rx_desc->wb.qword1.status_error_len);
715
-
rx_ptype = (qword & I40E_RXD_QW1_PTYPE_MASK) >>
716
-
I40E_RXD_QW1_PTYPE_SHIFT;
717
-
i40e_process_skb_fields(rx_ring, rx_desc, skb, rx_ptype);
718
-
719
-
vlan_tag = (qword & BIT(I40E_RX_DESC_STATUS_L2TAG1P_SHIFT)) ?
720
-
le16_to_cpu(rx_desc->wb.qword0.lo_dword.l2tag1) : 0;
721
-
i40e_receive_skb(rx_ring, skb, vlan_tag);
716
+
i40e_process_skb_fields(rx_ring, rx_desc, skb);
717
+
napi_gro_receive(&rx_ring->q_vector->napi, skb);
722
718
}
723
719
724
720
i40e_finalize_xdp_rx(rx_ring, xdp_xmit);
+10
-1
drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
+10
-1
drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
···
700
700
u8 num_tcs = adapter->hw_tcs;
701
701
u32 reg_val;
702
702
u32 queue;
703
-
u32 word;
704
703
705
704
/* remove VLAN filters beloning to this VF */
706
705
ixgbe_clear_vf_vlans(adapter, vf);
···
756
757
IXGBE_WRITE_REG(hw, IXGBE_PVFTXDCTL(reg_idx), reg_val);
757
758
}
758
759
}
760
+
761
+
IXGBE_WRITE_FLUSH(hw);
762
+
}
763
+
764
+
static void ixgbe_vf_clear_mbx(struct ixgbe_adapter *adapter, u32 vf)
765
+
{
766
+
struct ixgbe_hw *hw = &adapter->hw;
767
+
u32 word;
759
768
760
769
/* Clear VF's mailbox memory */
761
770
for (word = 0; word < IXGBE_VFMAILBOX_SIZE; word++)
···
837
830
838
831
/* reset the filters for the device */
839
832
ixgbe_vf_reset_event(adapter, vf);
833
+
834
+
ixgbe_vf_clear_mbx(adapter, vf);
840
835
841
836
/* set vf mac address */
842
837
if (!is_zero_ether_addr(vf_mac))
+3
-3
drivers/net/ethernet/marvell/mvneta.c
+3
-3
drivers/net/ethernet/marvell/mvneta.c
···
408
408
struct mvneta_pcpu_stats __percpu *stats;
409
409
410
410
int pkt_size;
411
-
unsigned int frag_size;
412
411
void __iomem *base;
413
412
struct mvneta_rx_queue *rxqs;
414
413
struct mvneta_tx_queue *txqs;
···
2904
2905
if (!pp->bm_priv) {
2905
2906
/* Set Offset */
2906
2907
mvneta_rxq_offset_set(pp, rxq, 0);
2907
-
mvneta_rxq_buf_size_set(pp, rxq, pp->frag_size);
2908
+
mvneta_rxq_buf_size_set(pp, rxq, PAGE_SIZE < SZ_64K ?
2909
+
PAGE_SIZE :
2910
+
MVNETA_RX_BUF_SIZE(pp->pkt_size));
2908
2911
mvneta_rxq_bm_disable(pp, rxq);
2909
2912
mvneta_rxq_fill(pp, rxq, rxq->size);
2910
2913
} else {
···
3761
3760
int ret;
3762
3761
3763
3762
pp->pkt_size = MVNETA_RX_PKT_SIZE(pp->dev->mtu);
3764
-
pp->frag_size = PAGE_SIZE;
3765
3763
3766
3764
ret = mvneta_setup_rxqs(pp);
3767
3765
if (ret)
+9
-7
drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
+9
-7
drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
···
4405
4405
case PHY_INTERFACE_MODE_10GKR:
4406
4406
case PHY_INTERFACE_MODE_XAUI:
4407
4407
case PHY_INTERFACE_MODE_NA:
4408
-
phylink_set(mask, 10000baseCR_Full);
4409
-
phylink_set(mask, 10000baseSR_Full);
4410
-
phylink_set(mask, 10000baseLR_Full);
4411
-
phylink_set(mask, 10000baseLRM_Full);
4412
-
phylink_set(mask, 10000baseER_Full);
4413
-
phylink_set(mask, 10000baseKR_Full);
4408
+
if (port->gop_id == 0) {
4409
+
phylink_set(mask, 10000baseT_Full);
4410
+
phylink_set(mask, 10000baseCR_Full);
4411
+
phylink_set(mask, 10000baseSR_Full);
4412
+
phylink_set(mask, 10000baseLR_Full);
4413
+
phylink_set(mask, 10000baseLRM_Full);
4414
+
phylink_set(mask, 10000baseER_Full);
4415
+
phylink_set(mask, 10000baseKR_Full);
4416
+
}
4414
4417
/* Fall-through */
4415
4418
case PHY_INTERFACE_MODE_RGMII:
4416
4419
case PHY_INTERFACE_MODE_RGMII_ID:
···
4424
4421
phylink_set(mask, 10baseT_Full);
4425
4422
phylink_set(mask, 100baseT_Half);
4426
4423
phylink_set(mask, 100baseT_Full);
4427
-
phylink_set(mask, 10000baseT_Full);
4428
4424
/* Fall-through */
4429
4425
case PHY_INTERFACE_MODE_1000BASEX:
4430
4426
case PHY_INTERFACE_MODE_2500BASEX:
+3
-8
drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
+3
-8
drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
···
1190
1190
struct ethtool_ts_info *info)
1191
1191
{
1192
1192
struct mlx5_core_dev *mdev = priv->mdev;
1193
-
int ret;
1194
-
1195
-
ret = ethtool_op_get_ts_info(priv->netdev, info);
1196
-
if (ret)
1197
-
return ret;
1198
1193
1199
1194
info->phc_index = mlx5_clock_get_ptp_index(mdev);
1200
1195
···
1197
1202
info->phc_index == -1)
1198
1203
return 0;
1199
1204
1200
-
info->so_timestamping |= SOF_TIMESTAMPING_TX_HARDWARE |
1201
-
SOF_TIMESTAMPING_RX_HARDWARE |
1202
-
SOF_TIMESTAMPING_RAW_HARDWARE;
1205
+
info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
1206
+
SOF_TIMESTAMPING_RX_HARDWARE |
1207
+
SOF_TIMESTAMPING_RAW_HARDWARE;
1203
1208
1204
1209
info->tx_types = BIT(HWTSTAMP_TX_OFF) |
1205
1210
BIT(HWTSTAMP_TX_ON);
+6
drivers/net/ethernet/mellanox/mlx5/core/en_main.c
+6
drivers/net/ethernet/mellanox/mlx5/core/en_main.c
···
128
128
return !params->lro_en && frag_sz <= PAGE_SIZE;
129
129
}
130
130
131
+
#define MLX5_MAX_MPWQE_LOG_WQE_STRIDE_SZ ((BIT(__mlx5_bit_sz(wq, log_wqe_stride_size)) - 1) + \
132
+
MLX5_MPWQE_LOG_STRIDE_SZ_BASE)
131
133
static bool mlx5e_rx_mpwqe_is_linear_skb(struct mlx5_core_dev *mdev,
132
134
struct mlx5e_params *params)
133
135
{
···
138
136
u8 log_num_strides;
139
137
140
138
if (!mlx5e_rx_is_linear_skb(mdev, params))
139
+
return false;
140
+
141
+
if (order_base_2(frag_sz) > MLX5_MAX_MPWQE_LOG_WQE_STRIDE_SZ)
141
142
return false;
142
143
143
144
if (MLX5_CAP_GEN(mdev, ext_stride_num_range))
···
1401
1396
struct mlx5_core_dev *mdev = c->mdev;
1402
1397
struct mlx5_rate_limit rl = {0};
1403
1398
1399
+
cancel_work_sync(&sq->dim.work);
1404
1400
mlx5e_destroy_sq(mdev, sq->sqn);
1405
1401
if (sq->rate_limit) {
1406
1402
rl.rate = sq->rate_limit;
+4
-5
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
+4
-5
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
···
46
46
47
47
#define MLX5E_REP_PARAMS_LOG_SQ_SIZE \
48
48
max(0x6, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)
49
+
#define MLX5E_REP_PARAMS_DEF_NUM_CHANNELS 1
49
50
50
51
static const char mlx5e_rep_driver_name[] = "mlx5e_rep";
51
52
···
467
466
468
467
ASSERT_RTNL();
469
468
470
-
if ((!neigh_connected && (e->flags & MLX5_ENCAP_ENTRY_VALID)) ||
471
-
!ether_addr_equal(e->h_dest, ha))
469
+
if ((e->flags & MLX5_ENCAP_ENTRY_VALID) &&
470
+
(!neigh_connected || !ether_addr_equal(e->h_dest, ha)))
472
471
mlx5e_tc_encap_flows_del(priv, e);
473
472
474
473
if (neigh_connected && !(e->flags & MLX5_ENCAP_ENTRY_VALID)) {
···
1084
1083
if (err)
1085
1084
return err;
1086
1085
1087
-
1088
-
priv->channels.params.num_channels =
1089
-
mlx5e_get_netdev_max_channels(netdev);
1086
+
priv->channels.params.num_channels = MLX5E_REP_PARAMS_DEF_NUM_CHANNELS;
1090
1087
1091
1088
mlx5e_build_rep_params(mdev, &priv->channels.params, netdev->mtu);
1092
1089
mlx5e_build_rep_netdev(netdev);
+6
-4
drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
+6
-4
drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
···
1190
1190
int mlx5e_poll_rx_cq(struct mlx5e_cq *cq, int budget)
1191
1191
{
1192
1192
struct mlx5e_rq *rq = container_of(cq, struct mlx5e_rq, cq);
1193
-
struct mlx5e_xdpsq *xdpsq;
1193
+
struct mlx5e_xdpsq *xdpsq = &rq->xdpsq;
1194
1194
struct mlx5_cqe64 *cqe;
1195
1195
int work_done = 0;
1196
1196
···
1201
1201
work_done += mlx5e_decompress_cqes_cont(rq, cq, 0, budget);
1202
1202
1203
1203
cqe = mlx5_cqwq_get_cqe(&cq->wq);
1204
-
if (!cqe)
1204
+
if (!cqe) {
1205
+
if (unlikely(work_done))
1206
+
goto out;
1205
1207
return 0;
1206
-
1207
-
xdpsq = &rq->xdpsq;
1208
+
}
1208
1209
1209
1210
do {
1210
1211
if (mlx5_get_cqe_format(cqe) == MLX5_COMPRESSED) {
···
1220
1219
rq->handle_rx_cqe(rq, cqe);
1221
1220
} while ((++work_done < budget) && (cqe = mlx5_cqwq_get_cqe(&cq->wq)));
1222
1221
1222
+
out:
1223
1223
if (xdpsq->doorbell) {
1224
1224
mlx5e_xmit_xdp_doorbell(xdpsq);
1225
1225
xdpsq->doorbell = false;
-2
drivers/net/ethernet/mellanox/mlx5/core/en_stats.c
-2
drivers/net/ethernet/mellanox/mlx5/core/en_stats.c
···
74
74
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_recover) },
75
75
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_cqes) },
76
76
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_wake) },
77
-
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_udp_seg_rem) },
78
77
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_cqe_err) },
79
78
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_xdp_xmit) },
80
79
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_xdp_full) },
···
197
198
s->tx_nop += sq_stats->nop;
198
199
s->tx_queue_stopped += sq_stats->stopped;
199
200
s->tx_queue_wake += sq_stats->wake;
200
-
s->tx_udp_seg_rem += sq_stats->udp_seg_rem;
201
201
s->tx_queue_dropped += sq_stats->dropped;
202
202
s->tx_cqe_err += sq_stats->cqe_err;
203
203
s->tx_recover += sq_stats->recover;
-2
drivers/net/ethernet/mellanox/mlx5/core/en_stats.h
-2
drivers/net/ethernet/mellanox/mlx5/core/en_stats.h
···
87
87
u64 tx_recover;
88
88
u64 tx_cqes;
89
89
u64 tx_queue_wake;
90
-
u64 tx_udp_seg_rem;
91
90
u64 tx_cqe_err;
92
91
u64 tx_xdp_xmit;
93
92
u64 tx_xdp_full;
···
220
221
u64 csum_partial_inner;
221
222
u64 added_vlan_packets;
222
223
u64 nop;
223
-
u64 udp_seg_rem;
224
224
#ifdef CONFIG_MLX5_EN_TLS
225
225
u64 tls_ooo;
226
226
u64 tls_resync_bytes;
+22
-14
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c
+22
-14
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c
···
870
870
struct mlx5_flow_handle *rule;
871
871
872
872
memcpy(slow_attr, flow->esw_attr, sizeof(*slow_attr));
873
-
slow_attr->action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
874
-
slow_attr->mirror_count = 0,
875
-
slow_attr->dest_chain = FDB_SLOW_PATH_CHAIN,
873
+
slow_attr->action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
874
+
slow_attr->mirror_count = 0;
875
+
slow_attr->dest_chain = FDB_SLOW_PATH_CHAIN;
876
876
877
877
rule = mlx5e_tc_offload_fdb_rules(esw, flow, spec, slow_attr);
878
878
if (!IS_ERR(rule))
···
887
887
struct mlx5_esw_flow_attr *slow_attr)
888
888
{
889
889
memcpy(slow_attr, flow->esw_attr, sizeof(*slow_attr));
890
+
slow_attr->action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
891
+
slow_attr->mirror_count = 0;
892
+
slow_attr->dest_chain = FDB_SLOW_PATH_CHAIN;
890
893
mlx5e_tc_unoffload_fdb_rules(esw, flow, slow_attr);
891
894
flow->flags &= ~MLX5E_TC_FLOW_SLOW;
892
895
}
···
910
907
struct mlx5e_priv *out_priv;
911
908
int err = 0, encap_err = 0;
912
909
913
-
/* if prios are not supported, keep the old behaviour of using same prio
914
-
* for all offloaded rules.
915
-
*/
916
-
if (!mlx5_eswitch_prios_supported(esw))
917
-
attr->prio = 1;
910
+
if (!mlx5_eswitch_prios_supported(esw) && attr->prio != 1) {
911
+
NL_SET_ERR_MSG(extack, "E-switch priorities unsupported, upgrade FW");
912
+
return -EOPNOTSUPP;
913
+
}
918
914
919
915
if (attr->chain > max_chain) {
920
916
NL_SET_ERR_MSG(extack, "Requested chain is out of supported range");
···
1096
1094
flow->rule[0] = rule;
1097
1095
}
1098
1096
1099
-
if (e->flags & MLX5_ENCAP_ENTRY_VALID) {
1100
-
e->flags &= ~MLX5_ENCAP_ENTRY_VALID;
1101
-
mlx5_packet_reformat_dealloc(priv->mdev, e->encap_id);
1102
-
}
1097
+
/* we know that the encap is valid */
1098
+
e->flags &= ~MLX5_ENCAP_ENTRY_VALID;
1099
+
mlx5_packet_reformat_dealloc(priv->mdev, e->encap_id);
1103
1100
}
1104
1101
1105
1102
static struct mlx5_fc *mlx5e_tc_get_counter(struct mlx5e_tc_flow *flow)
···
2967
2966
NL_SET_ERR_MSG(extack, "Requested destination chain is out of supported range");
2968
2967
return -EOPNOTSUPP;
2969
2968
}
2970
-
action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST |
2971
-
MLX5_FLOW_CONTEXT_ACTION_COUNT;
2969
+
action |= MLX5_FLOW_CONTEXT_ACTION_COUNT;
2972
2970
attr->dest_chain = dest_chain;
2973
2971
2974
2972
continue;
···
2979
2979
attr->action = action;
2980
2980
if (!actions_match_supported(priv, exts, parse_attr, flow, extack))
2981
2981
return -EOPNOTSUPP;
2982
+
2983
+
if (attr->dest_chain) {
2984
+
if (attr->action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {
2985
+
NL_SET_ERR_MSG(extack, "Mirroring goto chain rules isn't supported");
2986
+
return -EOPNOTSUPP;
2987
+
}
2988
+
attr->action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
2989
+
}
2982
2990
2983
2991
if (attr->mirror_count > 0 && !mlx5_esw_has_fwd_fdb(priv->mdev)) {
2984
2992
NL_SET_ERR_MSG_MOD(extack,
+1
-1
drivers/net/ethernet/mellanox/mlx5/core/fs_core.c
+1
-1
drivers/net/ethernet/mellanox/mlx5/core/fs_core.c
···
452
452
453
453
if ((fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) &&
454
454
--fte->dests_size) {
455
-
modify_mask = BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST),
455
+
modify_mask = BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST);
456
456
update_fte = true;
457
457
}
458
458
out:
+18
-1
drivers/net/ethernet/mellanox/mlxsw/core.c
+18
-1
drivers/net/ethernet/mellanox/mlxsw/core.c
···
81
81
struct mlxsw_core_port *ports;
82
82
unsigned int max_ports;
83
83
bool reload_fail;
84
+
bool fw_flash_in_progress;
84
85
unsigned long driver_priv[0];
85
86
/* driver_priv has to be always the last item */
86
87
};
···
429
428
struct rcu_head rcu;
430
429
};
431
430
432
-
#define MLXSW_EMAD_TIMEOUT_MS 200
431
+
#define MLXSW_EMAD_TIMEOUT_DURING_FW_FLASH_MS 3000
432
+
#define MLXSW_EMAD_TIMEOUT_MS 200
433
433
434
434
static void mlxsw_emad_trans_timeout_schedule(struct mlxsw_reg_trans *trans)
435
435
{
436
436
unsigned long timeout = msecs_to_jiffies(MLXSW_EMAD_TIMEOUT_MS);
437
+
438
+
if (trans->core->fw_flash_in_progress)
439
+
timeout = msecs_to_jiffies(MLXSW_EMAD_TIMEOUT_DURING_FW_FLASH_MS);
437
440
438
441
queue_delayed_work(trans->core->emad_wq, &trans->timeout_dw, timeout);
439
442
}
···
1858
1853
p_linear_size);
1859
1854
}
1860
1855
EXPORT_SYMBOL(mlxsw_core_kvd_sizes_get);
1856
+
1857
+
void mlxsw_core_fw_flash_start(struct mlxsw_core *mlxsw_core)
1858
+
{
1859
+
mlxsw_core->fw_flash_in_progress = true;
1860
+
}
1861
+
EXPORT_SYMBOL(mlxsw_core_fw_flash_start);
1862
+
1863
+
void mlxsw_core_fw_flash_end(struct mlxsw_core *mlxsw_core)
1864
+
{
1865
+
mlxsw_core->fw_flash_in_progress = false;
1866
+
}
1867
+
EXPORT_SYMBOL(mlxsw_core_fw_flash_end);
1861
1868
1862
1869
static int __init mlxsw_core_module_init(void)
1863
1870
{
+3
drivers/net/ethernet/mellanox/mlxsw/core.h
+3
drivers/net/ethernet/mellanox/mlxsw/core.h
···
292
292
u64 *p_single_size, u64 *p_double_size,
293
293
u64 *p_linear_size);
294
294
295
+
void mlxsw_core_fw_flash_start(struct mlxsw_core *mlxsw_core);
296
+
void mlxsw_core_fw_flash_end(struct mlxsw_core *mlxsw_core);
297
+
295
298
bool mlxsw_core_res_valid(struct mlxsw_core *mlxsw_core,
296
299
enum mlxsw_res_id res_id);
297
300
+7
-1
drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+7
-1
drivers/net/ethernet/mellanox/mlxsw/spectrum.c
···
309
309
},
310
310
.mlxsw_sp = mlxsw_sp
311
311
};
312
+
int err;
312
313
313
-
return mlxfw_firmware_flash(&mlxsw_sp_mlxfw_dev.mlxfw_dev, firmware);
314
+
mlxsw_core_fw_flash_start(mlxsw_sp->core);
315
+
err = mlxfw_firmware_flash(&mlxsw_sp_mlxfw_dev.mlxfw_dev, firmware);
316
+
mlxsw_core_fw_flash_end(mlxsw_sp->core);
317
+
318
+
return err;
314
319
}
315
320
316
321
static int mlxsw_sp_fw_rev_validate(struct mlxsw_sp *mlxsw_sp)
···
3526
3521
MLXSW_SP_RXL_MR_MARK(ACL2, TRAP_TO_CPU, MULTICAST, false),
3527
3522
/* NVE traps */
3528
3523
MLXSW_SP_RXL_MARK(NVE_ENCAP_ARP, TRAP_TO_CPU, ARP, false),
3524
+
MLXSW_SP_RXL_NO_MARK(NVE_DECAP_ARP, TRAP_TO_CPU, ARP, false),
3529
3525
};
3530
3526
3531
3527
static int mlxsw_sp_cpu_policers_set(struct mlxsw_core *mlxsw_core)
+1
-1
drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c
+1
-1
drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c
+1
drivers/net/ethernet/mellanox/mlxsw/trap.h
+1
drivers/net/ethernet/mellanox/mlxsw/trap.h
···
60
60
MLXSW_TRAP_ID_IPV6_MC_LINK_LOCAL_DEST = 0x91,
61
61
MLXSW_TRAP_ID_HOST_MISS_IPV6 = 0x92,
62
62
MLXSW_TRAP_ID_IPIP_DECAP_ERROR = 0xB1,
63
+
MLXSW_TRAP_ID_NVE_DECAP_ARP = 0xB8,
63
64
MLXSW_TRAP_ID_NVE_ENCAP_ARP = 0xBD,
64
65
MLXSW_TRAP_ID_ROUTER_ALERT_IPV4 = 0xD6,
65
66
MLXSW_TRAP_ID_ROUTER_ALERT_IPV6 = 0xD7,
+3
-8
drivers/net/ethernet/microchip/lan743x_main.c
+3
-8
drivers/net/ethernet/microchip/lan743x_main.c
···
802
802
u32 mac_addr_hi = 0;
803
803
u32 mac_addr_lo = 0;
804
804
u32 data;
805
-
int ret;
806
805
807
806
netdev = adapter->netdev;
808
-
lan743x_csr_write(adapter, MAC_CR, MAC_CR_RST_);
809
-
ret = lan743x_csr_wait_for_bit(adapter, MAC_CR, MAC_CR_RST_,
810
-
0, 1000, 20000, 100);
811
-
if (ret)
812
-
return ret;
813
807
814
808
/* setup auto duplex, and speed detection */
815
809
data = lan743x_csr_read(adapter, MAC_CR);
···
2713
2719
snprintf(adapter->mdiobus->id, MII_BUS_ID_SIZE,
2714
2720
"pci-%s", pci_name(adapter->pdev));
2715
2721
2716
-
/* set to internal PHY id */
2717
-
adapter->mdiobus->phy_mask = ~(u32)BIT(1);
2722
+
if ((adapter->csr.id_rev & ID_REV_ID_MASK_) == ID_REV_ID_LAN7430_)
2723
+
/* LAN7430 uses internal phy at address 1 */
2724
+
adapter->mdiobus->phy_mask = ~(u32)BIT(1);
2718
2725
2719
2726
/* register mdiobus */
2720
2727
ret = mdiobus_register(adapter->mdiobus);
+1
-1
drivers/net/ethernet/neterion/vxge/vxge-config.c
+1
-1
drivers/net/ethernet/neterion/vxge/vxge-config.c
···
808
808
struct vxge_hw_device_date *fw_date = &hw_info->fw_date;
809
809
struct vxge_hw_device_version *flash_version = &hw_info->flash_version;
810
810
struct vxge_hw_device_date *flash_date = &hw_info->flash_date;
811
-
u64 data0, data1 = 0, steer_ctrl = 0;
811
+
u64 data0 = 0, data1 = 0, steer_ctrl = 0;
812
812
enum vxge_hw_status status;
813
813
814
814
status = vxge_hw_vpath_fw_api(vpath,
+22
-6
drivers/net/ethernet/netronome/nfp/flower/offload.c
+22
-6
drivers/net/ethernet/netronome/nfp/flower/offload.c
···
345
345
!(tcp_flags & (TCPHDR_FIN | TCPHDR_SYN | TCPHDR_RST)))
346
346
return -EOPNOTSUPP;
347
347
348
-
/* We need to store TCP flags in the IPv4 key space, thus
349
-
* we need to ensure we include a IPv4 key layer if we have
350
-
* not done so already.
348
+
/* We need to store TCP flags in the either the IPv4 or IPv6 key
349
+
* space, thus we need to ensure we include a IPv4/IPv6 key
350
+
* layer if we have not done so already.
351
351
*/
352
-
if (!(key_layer & NFP_FLOWER_LAYER_IPV4)) {
353
-
key_layer |= NFP_FLOWER_LAYER_IPV4;
354
-
key_size += sizeof(struct nfp_flower_ipv4);
352
+
if (!key_basic)
353
+
return -EOPNOTSUPP;
354
+
355
+
if (!(key_layer & NFP_FLOWER_LAYER_IPV4) &&
356
+
!(key_layer & NFP_FLOWER_LAYER_IPV6)) {
357
+
switch (key_basic->n_proto) {
358
+
case cpu_to_be16(ETH_P_IP):
359
+
key_layer |= NFP_FLOWER_LAYER_IPV4;
360
+
key_size += sizeof(struct nfp_flower_ipv4);
361
+
break;
362
+
363
+
case cpu_to_be16(ETH_P_IPV6):
364
+
key_layer |= NFP_FLOWER_LAYER_IPV6;
365
+
key_size += sizeof(struct nfp_flower_ipv6);
366
+
break;
367
+
368
+
default:
369
+
return -EOPNOTSUPP;
370
+
}
355
371
}
356
372
}
357
373
+1
-1
drivers/net/ethernet/nuvoton/w90p910_ether.c
+1
-1
drivers/net/ethernet/nuvoton/w90p910_ether.c
+2
-1
drivers/net/ethernet/qlogic/qed/qed_hsi.h
+2
-1
drivers/net/ethernet/qlogic/qed/qed_hsi.h
···
12831
12831
MFW_DRV_MSG_BW_UPDATE10,
12832
12832
MFW_DRV_MSG_TRANSCEIVER_STATE_CHANGE,
12833
12833
MFW_DRV_MSG_BW_UPDATE11,
12834
-
MFW_DRV_MSG_OEM_CFG_UPDATE,
12834
+
MFW_DRV_MSG_RESERVED,
12835
12835
MFW_DRV_MSG_GET_TLV_REQ,
12836
+
MFW_DRV_MSG_OEM_CFG_UPDATE,
12836
12837
MFW_DRV_MSG_MAX
12837
12838
};
12838
12839
+1
drivers/net/ethernet/qlogic/qed/qed_ll2.c
+1
drivers/net/ethernet/qlogic/qed/qed_ll2.c
+1
-1
drivers/net/ethernet/realtek/r8169.c
+1
-1
drivers/net/ethernet/realtek/r8169.c
+1
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+1
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+2
-2
drivers/net/ieee802154/ca8210.c
+2
-2
drivers/net/ieee802154/ca8210.c
···
721
721
static void ca8210_rx_done(struct cas_control *cas_ctl)
722
722
{
723
723
u8 *buf;
724
-
u8 len;
724
+
unsigned int len;
725
725
struct work_priv_container *mlme_reset_wpc;
726
726
struct ca8210_priv *priv = cas_ctl->priv;
727
727
···
730
730
if (len > CA8210_SPI_BUF_SIZE) {
731
731
dev_crit(
732
732
&priv->spi->dev,
733
-
"Received packet len (%d) erroneously long\n",
733
+
"Received packet len (%u) erroneously long\n",
734
734
len
735
735
);
736
736
goto finish;
+2
-2
drivers/net/ieee802154/mac802154_hwsim.c
+2
-2
drivers/net/ieee802154/mac802154_hwsim.c
···
492
492
!info->attrs[MAC802154_HWSIM_ATTR_RADIO_EDGE])
493
493
return -EINVAL;
494
494
495
-
if (nla_parse_nested(edge_attrs, MAC802154_HWSIM_EDGE_ATTR_MAX + 1,
495
+
if (nla_parse_nested(edge_attrs, MAC802154_HWSIM_EDGE_ATTR_MAX,
496
496
info->attrs[MAC802154_HWSIM_ATTR_RADIO_EDGE],
497
497
hwsim_edge_policy, NULL))
498
498
return -EINVAL;
···
542
542
!info->attrs[MAC802154_HWSIM_ATTR_RADIO_EDGE])
543
543
return -EINVAL;
544
544
545
-
if (nla_parse_nested(edge_attrs, MAC802154_HWSIM_EDGE_ATTR_MAX + 1,
545
+
if (nla_parse_nested(edge_attrs, MAC802154_HWSIM_EDGE_ATTR_MAX,
546
546
info->attrs[MAC802154_HWSIM_ATTR_RADIO_EDGE],
547
547
hwsim_edge_policy, NULL))
548
548
return -EINVAL;
+2
-5
drivers/net/phy/phy_device.c
+2
-5
drivers/net/phy/phy_device.c
···
308
308
if (ret < 0)
309
309
return ret;
310
310
311
-
/* The PHY needs to renegotiate. */
312
-
phydev->link = 0;
313
-
phydev->state = PHY_UP;
314
-
315
-
phy_start_machine(phydev);
311
+
if (phydev->attached_dev && phydev->adjust_link)
312
+
phy_start_machine(phydev);
316
313
317
314
return 0;
318
315
}
+16
-2
drivers/net/usb/hso.c
+16
-2
drivers/net/usb/hso.c
···
2807
2807
return -EIO;
2808
2808
}
2809
2809
2810
+
/* check if we have a valid interface */
2811
+
if (if_num > 16) {
2812
+
kfree(config_data);
2813
+
return -EINVAL;
2814
+
}
2815
+
2810
2816
switch (config_data[if_num]) {
2811
2817
case 0x0:
2812
2818
result = 0;
···
2883
2877
2884
2878
/* Get the interface/port specification from either driver_info or from
2885
2879
* the device itself */
2886
-
if (id->driver_info)
2880
+
if (id->driver_info) {
2881
+
/* if_num is controlled by the device, driver_info is a 0 terminated
2882
+
* array. Make sure, the access is in bounds! */
2883
+
for (i = 0; i <= if_num; ++i)
2884
+
if (((u32 *)(id->driver_info))[i] == 0)
2885
+
goto exit;
2887
2886
port_spec = ((u32 *)(id->driver_info))[if_num];
2888
-
else
2887
+
} else {
2889
2888
port_spec = hso_get_config_data(interface);
2889
+
if (port_spec < 0)
2890
+
goto exit;
2891
+
}
2890
2892
2891
2893
/* Check if we need to switch to alt interfaces prior to port
2892
2894
* configuration */
+4
drivers/net/usb/lan78xx.c
+4
drivers/net/usb/lan78xx.c
···
2320
2320
ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2321
2321
ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2322
2322
2323
+
/* Added to support MAC address changes */
2324
+
ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2325
+
ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2326
+
2323
2327
return 0;
2324
2328
}
2325
2329
+2
drivers/net/usb/qmi_wwan.c
+2
drivers/net/usb/qmi_wwan.c
···
1117
1117
{QMI_FIXED_INTF(0x1435, 0xd181, 4)}, /* Wistron NeWeb D18Q1 */
1118
1118
{QMI_FIXED_INTF(0x1435, 0xd181, 5)}, /* Wistron NeWeb D18Q1 */
1119
1119
{QMI_FIXED_INTF(0x1435, 0xd191, 4)}, /* Wistron NeWeb D19Q1 */
1120
+
{QMI_QUIRK_SET_DTR(0x1508, 0x1001, 4)}, /* Fibocom NL668 series */
1120
1121
{QMI_FIXED_INTF(0x16d8, 0x6003, 0)}, /* CMOTech 6003 */
1121
1122
{QMI_FIXED_INTF(0x16d8, 0x6007, 0)}, /* CMOTech CHE-628S */
1122
1123
{QMI_FIXED_INTF(0x16d8, 0x6008, 0)}, /* CMOTech CMU-301 */
···
1230
1229
{QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */
1231
1230
{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */
1232
1231
{QMI_QUIRK_SET_DTR(0x1bc7, 0x1201, 2)}, /* Telit LE920, LE920A4 */
1232
+
{QMI_QUIRK_SET_DTR(0x1bc7, 0x1900, 1)}, /* Telit LN940 series */
1233
1233
{QMI_FIXED_INTF(0x1c9e, 0x9801, 3)}, /* Telewell TW-3G HSPA+ */
1234
1234
{QMI_FIXED_INTF(0x1c9e, 0x9803, 4)}, /* Telewell TW-3G HSPA+ */
1235
1235
{QMI_FIXED_INTF(0x1c9e, 0x9b01, 3)}, /* XS Stick W100-2 from 4G Systems */
+22
-11
drivers/net/usb/r8152.c
+22
-11
drivers/net/usb/r8152.c
···
129
129
#define USB_UPS_CTRL 0xd800
130
130
#define USB_POWER_CUT 0xd80a
131
131
#define USB_MISC_0 0xd81a
132
+
#define USB_MISC_1 0xd81f
132
133
#define USB_AFE_CTRL2 0xd824
133
134
#define USB_UPS_CFG 0xd842
134
135
#define USB_UPS_FLAGS 0xd848
···
556
555
557
556
/* MAC PASSTHRU */
558
557
#define AD_MASK 0xfee0
558
+
#define BND_MASK 0x0004
559
559
#define EFUSE 0xcfdb
560
560
#define PASS_THRU_MASK 0x1
561
561
···
1152
1150
return ret;
1153
1151
}
1154
1152
1155
-
/* Devices containing RTL8153-AD can support a persistent
1153
+
/* Devices containing proper chips can support a persistent
1156
1154
* host system provided MAC address.
1157
1155
* Examples of this are Dell TB15 and Dell WD15 docks
1158
1156
*/
···
1167
1165
1168
1166
/* test for -AD variant of RTL8153 */
1169
1167
ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
1170
-
if ((ocp_data & AD_MASK) != 0x1000)
1171
-
return -ENODEV;
1172
-
1173
-
/* test for MAC address pass-through bit */
1174
-
ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, EFUSE);
1175
-
if ((ocp_data & PASS_THRU_MASK) != 1)
1176
-
return -ENODEV;
1168
+
if ((ocp_data & AD_MASK) == 0x1000) {
1169
+
/* test for MAC address pass-through bit */
1170
+
ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, EFUSE);
1171
+
if ((ocp_data & PASS_THRU_MASK) != 1) {
1172
+
netif_dbg(tp, probe, tp->netdev,
1173
+
"No efuse for RTL8153-AD MAC pass through\n");
1174
+
return -ENODEV;
1175
+
}
1176
+
} else {
1177
+
/* test for RTL8153-BND */
1178
+
ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_1);
1179
+
if ((ocp_data & BND_MASK) == 0) {
1180
+
netif_dbg(tp, probe, tp->netdev,
1181
+
"Invalid variant for MAC pass through\n");
1182
+
return -ENODEV;
1183
+
}
1184
+
}
1177
1185
1178
1186
/* returns _AUXMAC_#AABBCCDDEEFF# */
1179
1187
status = acpi_evaluate_object(NULL, "\\_SB.AMAC", NULL, &buffer);
···
1229
1217
if (tp->version == RTL_VER_01) {
1230
1218
ret = pla_ocp_read(tp, PLA_IDR, 8, sa.sa_data);
1231
1219
} else {
1232
-
/* if this is not an RTL8153-AD, no eFuse mac pass thru set,
1233
-
* or system doesn't provide valid _SB.AMAC this will be
1234
-
* be expected to non-zero
1220
+
/* if device doesn't support MAC pass through this will
1221
+
* be expected to be non-zero
1235
1222
*/
1236
1223
ret = vendor_mac_passthru_addr_read(tp, &sa);
1237
1224
if (ret < 0)
+14
-7
drivers/net/vxlan.c
+14
-7
drivers/net/vxlan.c
···
568
568
rd->remote_port = port;
569
569
rd->remote_vni = vni;
570
570
rd->remote_ifindex = ifindex;
571
+
rd->offloaded = false;
571
572
return 1;
572
573
}
573
574
···
3259
3258
struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3260
3259
struct vxlan_dev *vxlan = netdev_priv(dev);
3261
3260
struct vxlan_fdb *f = NULL;
3261
+
bool unregister = false;
3262
3262
int err;
3263
3263
3264
3264
err = vxlan_dev_configure(net, dev, conf, false, extack);
···
3285
3283
err = register_netdevice(dev);
3286
3284
if (err)
3287
3285
goto errout;
3286
+
unregister = true;
3288
3287
3289
3288
err = rtnl_configure_link(dev, NULL);
3290
-
if (err) {
3291
-
unregister_netdevice(dev);
3289
+
if (err)
3292
3290
goto errout;
3293
-
}
3294
3291
3295
3292
/* notify default fdb entry */
3296
3293
if (f)
···
3297
3296
3298
3297
list_add(&vxlan->next, &vn->vxlan_list);
3299
3298
return 0;
3299
+
3300
3300
errout:
3301
+
/* unregister_netdevice() destroys the default FDB entry with deletion
3302
+
* notification. But the addition notification was not sent yet, so
3303
+
* destroy the entry by hand here.
3304
+
*/
3301
3305
if (f)
3302
3306
vxlan_fdb_destroy(vxlan, f, false);
3307
+
if (unregister)
3308
+
unregister_netdevice(dev);
3303
3309
return err;
3304
3310
}
3305
3311
···
3542
3534
struct vxlan_rdst *dst = &vxlan->default_dst;
3543
3535
struct vxlan_rdst old_dst;
3544
3536
struct vxlan_config conf;
3545
-
struct vxlan_fdb *f = NULL;
3546
3537
int err;
3547
3538
3548
3539
err = vxlan_nl2conf(tb, data,
···
3567
3560
old_dst.remote_ifindex, 0);
3568
3561
3569
3562
if (!vxlan_addr_any(&dst->remote_ip)) {
3570
-
err = vxlan_fdb_create(vxlan, all_zeros_mac,
3563
+
err = vxlan_fdb_update(vxlan, all_zeros_mac,
3571
3564
&dst->remote_ip,
3572
3565
NUD_REACHABLE | NUD_PERMANENT,
3566
+
NLM_F_APPEND | NLM_F_CREATE,
3573
3567
vxlan->cfg.dst_port,
3574
3568
dst->remote_vni,
3575
3569
dst->remote_vni,
3576
3570
dst->remote_ifindex,
3577
-
NTF_SELF, &f);
3571
+
NTF_SELF);
3578
3572
if (err) {
3579
3573
spin_unlock_bh(&vxlan->hash_lock);
3580
3574
return err;
3581
3575
}
3582
-
vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f), RTM_NEWNEIGH);
3583
3576
}
3584
3577
spin_unlock_bh(&vxlan->hash_lock);
3585
3578
}
+28
drivers/net/wireless/ath/ath10k/core.c
+28
drivers/net/wireless/ath/ath10k/core.c
···
2418
2418
return 0;
2419
2419
}
2420
2420
2421
+
static int ath10k_core_compat_services(struct ath10k *ar)
2422
+
{
2423
+
struct ath10k_fw_file *fw_file = &ar->normal_mode_fw.fw_file;
2424
+
2425
+
/* all 10.x firmware versions support thermal throttling but don't
2426
+
* advertise the support via service flags so we have to hardcode
2427
+
* it here
2428
+
*/
2429
+
switch (fw_file->wmi_op_version) {
2430
+
case ATH10K_FW_WMI_OP_VERSION_10_1:
2431
+
case ATH10K_FW_WMI_OP_VERSION_10_2:
2432
+
case ATH10K_FW_WMI_OP_VERSION_10_2_4:
2433
+
case ATH10K_FW_WMI_OP_VERSION_10_4:
2434
+
set_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map);
2435
+
break;
2436
+
default:
2437
+
break;
2438
+
}
2439
+
2440
+
return 0;
2441
+
}
2442
+
2421
2443
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode,
2422
2444
const struct ath10k_fw_components *fw)
2423
2445
{
···
2636
2614
status = ath10k_wmi_wait_for_unified_ready(ar);
2637
2615
if (status) {
2638
2616
ath10k_err(ar, "wmi unified ready event not received\n");
2617
+
goto err_hif_stop;
2618
+
}
2619
+
2620
+
status = ath10k_core_compat_services(ar);
2621
+
if (status) {
2622
+
ath10k_err(ar, "compat services failed: %d\n", status);
2639
2623
goto err_hif_stop;
2640
2624
}
2641
2625
+3
-2
drivers/net/wireless/ath/ath10k/debug.c
+3
-2
drivers/net/wireless/ath/ath10k/debug.c
···
2578
2578
debugfs_create_file("pktlog_filter", 0644, ar->debug.debugfs_phy, ar,
2579
2579
&fops_pktlog_filter);
2580
2580
2581
-
debugfs_create_file("quiet_period", 0644, ar->debug.debugfs_phy, ar,
2582
-
&fops_quiet_period);
2581
+
if (test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
2582
+
debugfs_create_file("quiet_period", 0644, ar->debug.debugfs_phy, ar,
2583
+
&fops_quiet_period);
2583
2584
2584
2585
debugfs_create_file("tpc_stats", 0400, ar->debug.debugfs_phy, ar,
2585
2586
&fops_tpc_stats);
+9
drivers/net/wireless/ath/ath10k/thermal.c
+9
drivers/net/wireless/ath/ath10k/thermal.c
···
140
140
141
141
lockdep_assert_held(&ar->conf_mutex);
142
142
143
+
if (!test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
144
+
return;
145
+
143
146
if (!ar->wmi.ops->gen_pdev_set_quiet_mode)
144
147
return;
145
148
···
167
164
struct thermal_cooling_device *cdev;
168
165
struct device *hwmon_dev;
169
166
int ret;
167
+
168
+
if (!test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
169
+
return 0;
170
170
171
171
cdev = thermal_cooling_device_register("ath10k_thermal", ar,
172
172
&ath10k_thermal_ops);
···
222
216
223
217
void ath10k_thermal_unregister(struct ath10k *ar)
224
218
{
219
+
if (!test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
220
+
return;
221
+
225
222
sysfs_remove_link(&ar->dev->kobj, "cooling_device");
226
223
thermal_cooling_device_unregister(ar->thermal.cdev);
227
224
}
+3
drivers/net/wireless/ath/ath10k/wmi-tlv.h
+3
drivers/net/wireless/ath/ath10k/wmi-tlv.h
+1
drivers/net/wireless/ath/ath10k/wmi.h
+1
drivers/net/wireless/ath/ath10k/wmi.h
+9
drivers/net/wireless/intel/iwlwifi/mvm/fw.c
+9
drivers/net/wireless/intel/iwlwifi/mvm/fw.c
···
881
881
int ret, i, j;
882
882
u16 cmd_wide_id = WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT);
883
883
884
+
/*
885
+
* This command is not supported on earlier firmware versions.
886
+
* Unfortunately, we don't have a TLV API flag to rely on, so
887
+
* rely on the major version which is in the first byte of
888
+
* ucode_ver.
889
+
*/
890
+
if (IWL_UCODE_SERIAL(mvm->fw->ucode_ver) < 41)
891
+
return 0;
892
+
884
893
ret = iwl_mvm_sar_get_wgds_table(mvm);
885
894
if (ret < 0) {
886
895
IWL_DEBUG_RADIO(mvm,
+2
-3
drivers/net/wireless/marvell/mwifiex/11n.c
+2
-3
drivers/net/wireless/marvell/mwifiex/11n.c
···
696
696
"Send delba to tid=%d, %pM\n",
697
697
tid, rx_reor_tbl_ptr->ta);
698
698
mwifiex_send_delba(priv, tid, rx_reor_tbl_ptr->ta, 0);
699
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
700
-
flags);
701
-
return;
699
+
goto exit;
702
700
}
703
701
}
702
+
exit:
704
703
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
705
704
}
706
705
+49
-47
drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
+49
-47
drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
···
103
103
* There could be holes in the buffer, which are skipped by the function.
104
104
* Since the buffer is linear, the function uses rotation to simulate
105
105
* circular buffer.
106
-
*
107
-
* The caller must hold rx_reorder_tbl_lock spinlock.
108
106
*/
109
107
static void
110
108
mwifiex_11n_dispatch_pkt_until_start_win(struct mwifiex_private *priv,
···
111
113
{
112
114
int pkt_to_send, i;
113
115
void *rx_tmp_ptr;
116
+
unsigned long flags;
114
117
115
118
pkt_to_send = (start_win > tbl->start_win) ?
116
119
min((start_win - tbl->start_win), tbl->win_size) :
117
120
tbl->win_size;
118
121
119
122
for (i = 0; i < pkt_to_send; ++i) {
123
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
120
124
rx_tmp_ptr = NULL;
121
125
if (tbl->rx_reorder_ptr[i]) {
122
126
rx_tmp_ptr = tbl->rx_reorder_ptr[i];
123
127
tbl->rx_reorder_ptr[i] = NULL;
124
128
}
129
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
125
130
if (rx_tmp_ptr)
126
131
mwifiex_11n_dispatch_pkt(priv, rx_tmp_ptr);
127
132
}
128
133
134
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
129
135
/*
130
136
* We don't have a circular buffer, hence use rotation to simulate
131
137
* circular buffer
···
140
138
}
141
139
142
140
tbl->start_win = start_win;
141
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
143
142
}
144
143
145
144
/*
···
150
147
* The start window is adjusted automatically when a hole is located.
151
148
* Since the buffer is linear, the function uses rotation to simulate
152
149
* circular buffer.
153
-
*
154
-
* The caller must hold rx_reorder_tbl_lock spinlock.
155
150
*/
156
151
static void
157
152
mwifiex_11n_scan_and_dispatch(struct mwifiex_private *priv,
···
157
156
{
158
157
int i, j, xchg;
159
158
void *rx_tmp_ptr;
159
+
unsigned long flags;
160
160
161
161
for (i = 0; i < tbl->win_size; ++i) {
162
-
if (!tbl->rx_reorder_ptr[i])
162
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
163
+
if (!tbl->rx_reorder_ptr[i]) {
164
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
165
+
flags);
163
166
break;
167
+
}
164
168
rx_tmp_ptr = tbl->rx_reorder_ptr[i];
165
169
tbl->rx_reorder_ptr[i] = NULL;
170
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
166
171
mwifiex_11n_dispatch_pkt(priv, rx_tmp_ptr);
167
172
}
168
173
174
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
169
175
/*
170
176
* We don't have a circular buffer, hence use rotation to simulate
171
177
* circular buffer
···
185
177
}
186
178
}
187
179
tbl->start_win = (tbl->start_win + i) & (MAX_TID_VALUE - 1);
180
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
188
181
}
189
182
190
183
/*
···
193
184
*
194
185
* The function stops the associated timer and dispatches all the
195
186
* pending packets in the Rx reorder table before deletion.
196
-
*
197
-
* The caller must hold rx_reorder_tbl_lock spinlock.
198
187
*/
199
188
static void
200
189
mwifiex_del_rx_reorder_entry(struct mwifiex_private *priv,
···
218
211
219
212
del_timer_sync(&tbl->timer_context.timer);
220
213
tbl->timer_context.timer_is_set = false;
214
+
215
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
221
216
list_del(&tbl->list);
217
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
218
+
222
219
kfree(tbl->rx_reorder_ptr);
223
220
kfree(tbl);
224
221
···
235
224
/*
236
225
* This function returns the pointer to an entry in Rx reordering
237
226
* table which matches the given TA/TID pair.
238
-
*
239
-
* The caller must hold rx_reorder_tbl_lock spinlock.
240
227
*/
241
228
struct mwifiex_rx_reorder_tbl *
242
229
mwifiex_11n_get_rx_reorder_tbl(struct mwifiex_private *priv, int tid, u8 *ta)
243
230
{
244
231
struct mwifiex_rx_reorder_tbl *tbl;
232
+
unsigned long flags;
245
233
246
-
list_for_each_entry(tbl, &priv->rx_reorder_tbl_ptr, list)
247
-
if (!memcmp(tbl->ta, ta, ETH_ALEN) && tbl->tid == tid)
234
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
235
+
list_for_each_entry(tbl, &priv->rx_reorder_tbl_ptr, list) {
236
+
if (!memcmp(tbl->ta, ta, ETH_ALEN) && tbl->tid == tid) {
237
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
238
+
flags);
248
239
return tbl;
240
+
}
241
+
}
242
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
249
243
250
244
return NULL;
251
245
}
···
267
251
return;
268
252
269
253
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
270
-
list_for_each_entry_safe(tbl, tmp, &priv->rx_reorder_tbl_ptr, list)
271
-
if (!memcmp(tbl->ta, ta, ETH_ALEN))
254
+
list_for_each_entry_safe(tbl, tmp, &priv->rx_reorder_tbl_ptr, list) {
255
+
if (!memcmp(tbl->ta, ta, ETH_ALEN)) {
256
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
257
+
flags);
272
258
mwifiex_del_rx_reorder_entry(priv, tbl);
259
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
260
+
}
261
+
}
273
262
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
274
263
275
264
return;
···
283
262
/*
284
263
* This function finds the last sequence number used in the packets
285
264
* buffered in Rx reordering table.
286
-
*
287
-
* The caller must hold rx_reorder_tbl_lock spinlock.
288
265
*/
289
266
static int
290
267
mwifiex_11n_find_last_seq_num(struct reorder_tmr_cnxt *ctx)
291
268
{
292
269
struct mwifiex_rx_reorder_tbl *rx_reorder_tbl_ptr = ctx->ptr;
270
+
struct mwifiex_private *priv = ctx->priv;
271
+
unsigned long flags;
293
272
int i;
294
273
295
-
for (i = rx_reorder_tbl_ptr->win_size - 1; i >= 0; --i)
296
-
if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
274
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
275
+
for (i = rx_reorder_tbl_ptr->win_size - 1; i >= 0; --i) {
276
+
if (rx_reorder_tbl_ptr->rx_reorder_ptr[i]) {
277
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
278
+
flags);
297
279
return i;
280
+
}
281
+
}
282
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
298
283
299
284
return -1;
300
285
}
···
318
291
struct reorder_tmr_cnxt *ctx =
319
292
from_timer(ctx, t, timer);
320
293
int start_win, seq_num;
321
-
unsigned long flags;
322
294
323
295
ctx->timer_is_set = false;
324
-
spin_lock_irqsave(&ctx->priv->rx_reorder_tbl_lock, flags);
325
296
seq_num = mwifiex_11n_find_last_seq_num(ctx);
326
297
327
-
if (seq_num < 0) {
328
-
spin_unlock_irqrestore(&ctx->priv->rx_reorder_tbl_lock, flags);
298
+
if (seq_num < 0)
329
299
return;
330
-
}
331
300
332
301
mwifiex_dbg(ctx->priv->adapter, INFO, "info: flush data %d\n", seq_num);
333
302
start_win = (ctx->ptr->start_win + seq_num + 1) & (MAX_TID_VALUE - 1);
334
303
mwifiex_11n_dispatch_pkt_until_start_win(ctx->priv, ctx->ptr,
335
304
start_win);
336
-
spin_unlock_irqrestore(&ctx->priv->rx_reorder_tbl_lock, flags);
337
305
}
338
306
339
307
/*
···
355
333
* If we get a TID, ta pair which is already present dispatch all the
356
334
* the packets and move the window size until the ssn
357
335
*/
358
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
359
336
tbl = mwifiex_11n_get_rx_reorder_tbl(priv, tid, ta);
360
337
if (tbl) {
361
338
mwifiex_11n_dispatch_pkt_until_start_win(priv, tbl, seq_num);
362
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
363
339
return;
364
340
}
365
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
366
341
/* if !tbl then create one */
367
342
new_node = kzalloc(sizeof(struct mwifiex_rx_reorder_tbl), GFP_KERNEL);
368
343
if (!new_node)
···
570
551
int prev_start_win, start_win, end_win, win_size;
571
552
u16 pkt_index;
572
553
bool init_window_shift = false;
573
-
unsigned long flags;
574
554
int ret = 0;
575
555
576
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
577
556
tbl = mwifiex_11n_get_rx_reorder_tbl(priv, tid, ta);
578
557
if (!tbl) {
579
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
580
558
if (pkt_type != PKT_TYPE_BAR)
581
559
mwifiex_11n_dispatch_pkt(priv, payload);
582
560
return ret;
583
561
}
584
562
585
563
if ((pkt_type == PKT_TYPE_AMSDU) && !tbl->amsdu) {
586
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
587
564
mwifiex_11n_dispatch_pkt(priv, payload);
588
565
return ret;
589
566
}
···
666
651
if (!tbl->timer_context.timer_is_set ||
667
652
prev_start_win != tbl->start_win)
668
653
mwifiex_11n_rxreorder_timer_restart(tbl);
669
-
670
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
671
654
return ret;
672
655
}
673
656
···
694
681
peer_mac, tid, initiator);
695
682
696
683
if (cleanup_rx_reorder_tbl) {
697
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
698
684
tbl = mwifiex_11n_get_rx_reorder_tbl(priv, tid,
699
685
peer_mac);
700
686
if (!tbl) {
701
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
702
-
flags);
703
687
mwifiex_dbg(priv->adapter, EVENT,
704
688
"event: TID, TA not found in table\n");
705
689
return;
706
690
}
707
691
mwifiex_del_rx_reorder_entry(priv, tbl);
708
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
709
692
} else {
710
693
ptx_tbl = mwifiex_get_ba_tbl(priv, tid, peer_mac);
711
694
if (!ptx_tbl) {
···
735
726
int tid, win_size;
736
727
struct mwifiex_rx_reorder_tbl *tbl;
737
728
uint16_t block_ack_param_set;
738
-
unsigned long flags;
739
729
740
730
block_ack_param_set = le16_to_cpu(add_ba_rsp->block_ack_param_set);
741
731
···
748
740
mwifiex_dbg(priv->adapter, ERROR, "ADDBA RSP: failed %pM tid=%d)\n",
749
741
add_ba_rsp->peer_mac_addr, tid);
750
742
751
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
752
743
tbl = mwifiex_11n_get_rx_reorder_tbl(priv, tid,
753
744
add_ba_rsp->peer_mac_addr);
754
745
if (tbl)
755
746
mwifiex_del_rx_reorder_entry(priv, tbl);
756
747
757
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
758
748
return 0;
759
749
}
760
750
761
751
win_size = (block_ack_param_set & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK)
762
752
>> BLOCKACKPARAM_WINSIZE_POS;
763
753
764
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
765
754
tbl = mwifiex_11n_get_rx_reorder_tbl(priv, tid,
766
755
add_ba_rsp->peer_mac_addr);
767
756
if (tbl) {
···
769
764
else
770
765
tbl->amsdu = false;
771
766
}
772
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
773
767
774
768
mwifiex_dbg(priv->adapter, CMD,
775
769
"cmd: ADDBA RSP: %pM tid=%d ssn=%d win_size=%d\n",
···
808
804
809
805
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
810
806
list_for_each_entry_safe(del_tbl_ptr, tmp_node,
811
-
&priv->rx_reorder_tbl_ptr, list)
807
+
&priv->rx_reorder_tbl_ptr, list) {
808
+
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
812
809
mwifiex_del_rx_reorder_entry(priv, del_tbl_ptr);
810
+
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
811
+
}
813
812
INIT_LIST_HEAD(&priv->rx_reorder_tbl_ptr);
814
813
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
815
814
···
936
929
int tlv_buf_left = len;
937
930
int ret;
938
931
u8 *tmp;
939
-
unsigned long flags;
940
932
941
933
mwifiex_dbg_dump(priv->adapter, EVT_D, "RXBA_SYNC event:",
942
934
event_buf, len);
···
955
949
tlv_rxba->mac, tlv_rxba->tid, tlv_seq_num,
956
950
tlv_bitmap_len);
957
951
958
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
959
952
rx_reor_tbl_ptr =
960
953
mwifiex_11n_get_rx_reorder_tbl(priv, tlv_rxba->tid,
961
954
tlv_rxba->mac);
962
955
if (!rx_reor_tbl_ptr) {
963
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock,
964
-
flags);
965
956
mwifiex_dbg(priv->adapter, ERROR,
966
957
"Can not find rx_reorder_tbl!");
967
958
return;
968
959
}
969
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
970
960
971
961
for (i = 0; i < tlv_bitmap_len; i++) {
972
962
for (j = 0 ; j < 8; j++) {
-3
drivers/net/wireless/marvell/mwifiex/uap_txrx.c
-3
drivers/net/wireless/marvell/mwifiex/uap_txrx.c
···
421
421
spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
422
422
}
423
423
424
-
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
425
424
if (!priv->ap_11n_enabled ||
426
425
(!mwifiex_11n_get_rx_reorder_tbl(priv, uap_rx_pd->priority, ta) &&
427
426
(le16_to_cpu(uap_rx_pd->rx_pkt_type) != PKT_TYPE_AMSDU))) {
428
427
ret = mwifiex_handle_uap_rx_forward(priv, skb);
429
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
430
428
return ret;
431
429
}
432
-
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
433
430
434
431
/* Reorder and send to kernel */
435
432
pkt_type = (u8)le16_to_cpu(uap_rx_pd->rx_pkt_type);
+6
-1
drivers/net/wireless/mediatek/mt76/tx.c
+6
-1
drivers/net/wireless/mediatek/mt76/tx.c
···
400
400
401
401
for (i = 0; i < ARRAY_SIZE(sta->txq); i++) {
402
402
struct ieee80211_txq *txq = sta->txq[i];
403
-
struct mt76_txq *mtxq = (struct mt76_txq *) txq->drv_priv;
403
+
struct mt76_txq *mtxq;
404
+
405
+
if (!txq)
406
+
continue;
407
+
408
+
mtxq = (struct mt76_txq *)txq->drv_priv;
404
409
405
410
spin_lock_bh(&mtxq->hwq->lock);
406
411
mtxq->send_bar = mtxq->aggr && send_bar;
+1
drivers/net/wireless/realtek/rtlwifi/base.c
+1
drivers/net/wireless/realtek/rtlwifi/base.c
+1
-1
drivers/net/xen-netfront.c
+1
-1
drivers/net/xen-netfront.c
···
905
905
if (skb_shinfo(skb)->nr_frags == MAX_SKB_FRAGS) {
906
906
unsigned int pull_to = NETFRONT_SKB_CB(skb)->pull_to;
907
907
908
-
BUG_ON(pull_to <= skb_headlen(skb));
908
+
BUG_ON(pull_to < skb_headlen(skb));
909
909
__pskb_pull_tail(skb, pull_to - skb_headlen(skb));
910
910
}
911
911
if (unlikely(skb_shinfo(skb)->nr_frags >= MAX_SKB_FRAGS)) {
+7
-1
drivers/vhost/net.c
+7
-1
drivers/vhost/net.c
···
513
513
struct socket *sock;
514
514
struct vhost_virtqueue *vq = poll_rx ? tvq : rvq;
515
515
516
-
mutex_lock_nested(&vq->mutex, poll_rx ? VHOST_NET_VQ_TX: VHOST_NET_VQ_RX);
516
+
/* Try to hold the vq mutex of the paired virtqueue. We can't
517
+
* use mutex_lock() here since we could not guarantee a
518
+
* consistenet lock ordering.
519
+
*/
520
+
if (!mutex_trylock(&vq->mutex))
521
+
return;
522
+
517
523
vhost_disable_notify(&net->dev, vq);
518
524
sock = rvq->private_data;
519
525
+19
-4
drivers/vhost/vhost.c
+19
-4
drivers/vhost/vhost.c
···
295
295
{
296
296
int i;
297
297
298
-
for (i = 0; i < d->nvqs; ++i) {
299
-
mutex_lock(&d->vqs[i]->mutex);
298
+
for (i = 0; i < d->nvqs; ++i)
300
299
__vhost_vq_meta_reset(d->vqs[i]);
301
-
mutex_unlock(&d->vqs[i]->mutex);
302
-
}
303
300
}
304
301
305
302
static void vhost_vq_reset(struct vhost_dev *dev,
···
892
895
#define vhost_get_used(vq, x, ptr) \
893
896
vhost_get_user(vq, x, ptr, VHOST_ADDR_USED)
894
897
898
+
static void vhost_dev_lock_vqs(struct vhost_dev *d)
899
+
{
900
+
int i = 0;
901
+
for (i = 0; i < d->nvqs; ++i)
902
+
mutex_lock_nested(&d->vqs[i]->mutex, i);
903
+
}
904
+
905
+
static void vhost_dev_unlock_vqs(struct vhost_dev *d)
906
+
{
907
+
int i = 0;
908
+
for (i = 0; i < d->nvqs; ++i)
909
+
mutex_unlock(&d->vqs[i]->mutex);
910
+
}
911
+
895
912
static int vhost_new_umem_range(struct vhost_umem *umem,
896
913
u64 start, u64 size, u64 end,
897
914
u64 userspace_addr, int perm)
···
987
976
int ret = 0;
988
977
989
978
mutex_lock(&dev->mutex);
979
+
vhost_dev_lock_vqs(dev);
990
980
switch (msg->type) {
991
981
case VHOST_IOTLB_UPDATE:
992
982
if (!dev->iotlb) {
···
1021
1009
break;
1022
1010
}
1023
1011
1012
+
vhost_dev_unlock_vqs(dev);
1024
1013
mutex_unlock(&dev->mutex);
1025
1014
1026
1015
return ret;
···
2233
2220
return -EFAULT;
2234
2221
}
2235
2222
if (unlikely(vq->log_used)) {
2223
+
/* Make sure used idx is seen before log. */
2224
+
smp_wmb();
2236
2225
/* Log used index update. */
2237
2226
log_write(vq->log_base,
2238
2227
vq->log_addr + offsetof(struct vring_used, idx),
+1
-1
include/linux/filter.h
+1
-1
include/linux/filter.h
+6
-4
include/linux/mlx5/mlx5_ifc.h
+6
-4
include/linux/mlx5/mlx5_ifc.h
···
582
582
};
583
583
584
584
struct mlx5_ifc_flow_table_eswitch_cap_bits {
585
-
u8 reserved_at_0[0x1c];
586
-
u8 fdb_multi_path_to_table[0x1];
587
-
u8 reserved_at_1d[0x1];
585
+
u8 reserved_at_0[0x1a];
588
586
u8 multi_fdb_encap[0x1];
589
-
u8 reserved_at_1e[0x1e1];
587
+
u8 reserved_at_1b[0x1];
588
+
u8 fdb_multi_path_to_table[0x1];
589
+
u8 reserved_at_1d[0x3];
590
+
591
+
u8 reserved_at_20[0x1e0];
590
592
591
593
struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_esw_fdb;
592
594
+1
-1
include/linux/mod_devicetable.h
+1
-1
include/linux/mod_devicetable.h
···
565
565
/**
566
566
* struct mdio_device_id - identifies PHY devices on an MDIO/MII bus
567
567
* @phy_id: The result of
568
-
* (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&PHYSID2)) & @phy_id_mask
568
+
* (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&MII_PHYSID2)) & @phy_id_mask
569
569
* for this PHY type
570
570
* @phy_id_mask: Defines the significant bits of @phy_id. A value of 0
571
571
* is used to terminate an array of struct mdio_device_id.
-12
include/linux/netfilter/nfnetlink.h
-12
include/linux/netfilter/nfnetlink.h
···
62
62
}
63
63
#endif /* CONFIG_PROVE_LOCKING */
64
64
65
-
/*
66
-
* nfnl_dereference - fetch RCU pointer when updates are prevented by subsys mutex
67
-
*
68
-
* @p: The pointer to read, prior to dereferencing
69
-
* @ss: The nfnetlink subsystem ID
70
-
*
71
-
* Return the value of the specified RCU-protected pointer, but omit
72
-
* the READ_ONCE(), because caller holds the NFNL subsystem mutex.
73
-
*/
74
-
#define nfnl_dereference(p, ss) \
75
-
rcu_dereference_protected(p, lockdep_nfnl_is_held(ss))
76
-
77
65
#define MODULE_ALIAS_NFNL_SUBSYS(subsys) \
78
66
MODULE_ALIAS("nfnetlink-subsys-" __stringify(subsys))
79
67
-19
include/net/ip_tunnels.h
-19
include/net/ip_tunnels.h
···
144
144
bool ignore_df;
145
145
};
146
146
147
-
#define TUNNEL_CSUM __cpu_to_be16(0x01)
148
-
#define TUNNEL_ROUTING __cpu_to_be16(0x02)
149
-
#define TUNNEL_KEY __cpu_to_be16(0x04)
150
-
#define TUNNEL_SEQ __cpu_to_be16(0x08)
151
-
#define TUNNEL_STRICT __cpu_to_be16(0x10)
152
-
#define TUNNEL_REC __cpu_to_be16(0x20)
153
-
#define TUNNEL_VERSION __cpu_to_be16(0x40)
154
-
#define TUNNEL_NO_KEY __cpu_to_be16(0x80)
155
-
#define TUNNEL_DONT_FRAGMENT __cpu_to_be16(0x0100)
156
-
#define TUNNEL_OAM __cpu_to_be16(0x0200)
157
-
#define TUNNEL_CRIT_OPT __cpu_to_be16(0x0400)
158
-
#define TUNNEL_GENEVE_OPT __cpu_to_be16(0x0800)
159
-
#define TUNNEL_VXLAN_OPT __cpu_to_be16(0x1000)
160
-
#define TUNNEL_NOCACHE __cpu_to_be16(0x2000)
161
-
#define TUNNEL_ERSPAN_OPT __cpu_to_be16(0x4000)
162
-
163
-
#define TUNNEL_OPTIONS_PRESENT \
164
-
(TUNNEL_GENEVE_OPT | TUNNEL_VXLAN_OPT | TUNNEL_ERSPAN_OPT)
165
-
166
147
struct tnl_ptk_info {
167
148
__be16 flags;
168
149
__be16 proto;
+21
-4
include/net/sock.h
+21
-4
include/net/sock.h
···
2340
2340
void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags);
2341
2341
2342
2342
/**
2343
-
* sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
2343
+
* _sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
2344
2344
* @sk: socket sending this packet
2345
2345
* @tsflags: timestamping flags to use
2346
2346
* @tx_flags: completed with instructions for time stamping
2347
+
* @tskey: filled in with next sk_tskey (not for TCP, which uses seqno)
2347
2348
*
2348
2349
* Note: callers should take care of initial ``*tx_flags`` value (usually 0)
2349
2350
*/
2350
-
static inline void sock_tx_timestamp(const struct sock *sk, __u16 tsflags,
2351
-
__u8 *tx_flags)
2351
+
static inline void _sock_tx_timestamp(struct sock *sk, __u16 tsflags,
2352
+
__u8 *tx_flags, __u32 *tskey)
2352
2353
{
2353
-
if (unlikely(tsflags))
2354
+
if (unlikely(tsflags)) {
2354
2355
__sock_tx_timestamp(tsflags, tx_flags);
2356
+
if (tsflags & SOF_TIMESTAMPING_OPT_ID && tskey &&
2357
+
tsflags & SOF_TIMESTAMPING_TX_RECORD_MASK)
2358
+
*tskey = sk->sk_tskey++;
2359
+
}
2355
2360
if (unlikely(sock_flag(sk, SOCK_WIFI_STATUS)))
2356
2361
*tx_flags |= SKBTX_WIFI_STATUS;
2362
+
}
2363
+
2364
+
static inline void sock_tx_timestamp(struct sock *sk, __u16 tsflags,
2365
+
__u8 *tx_flags)
2366
+
{
2367
+
_sock_tx_timestamp(sk, tsflags, tx_flags, NULL);
2368
+
}
2369
+
2370
+
static inline void skb_setup_tx_timestamp(struct sk_buff *skb, __u16 tsflags)
2371
+
{
2372
+
_sock_tx_timestamp(skb->sk, tsflags, &skb_shinfo(skb)->tx_flags,
2373
+
&skb_shinfo(skb)->tskey);
2357
2374
}
2358
2375
2359
2376
/**
+6
include/net/tls.h
+6
include/net/tls.h
···
76
76
*
77
77
* void (*unhash)(struct tls_device *device, struct sock *sk);
78
78
* This function cleans listen state set by Inline TLS driver
79
+
*
80
+
* void (*release)(struct kref *kref);
81
+
* Release the registered device and allocated resources
82
+
* @kref: Number of reference to tls_device
79
83
*/
80
84
struct tls_device {
81
85
char name[TLS_DEVICE_NAME_MAX];
···
87
83
int (*feature)(struct tls_device *device);
88
84
int (*hash)(struct tls_device *device, struct sock *sk);
89
85
void (*unhash)(struct tls_device *device, struct sock *sk);
86
+
void (*release)(struct kref *kref);
87
+
struct kref kref;
90
88
};
91
89
92
90
enum {
+1
include/net/xfrm.h
+1
include/net/xfrm.h
···
1552
1552
int (*func)(struct xfrm_state *, int, void*), void *);
1553
1553
void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net);
1554
1554
struct xfrm_state *xfrm_state_alloc(struct net *net);
1555
+
void xfrm_state_free(struct xfrm_state *x);
1555
1556
struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
1556
1557
const xfrm_address_t *saddr,
1557
1558
const struct flowi *fl,
+1
include/uapi/asm-generic/Kbuild.asm
+1
include/uapi/asm-generic/Kbuild.asm
+20
include/uapi/linux/if_tunnel.h
+20
include/uapi/linux/if_tunnel.h
···
160
160
};
161
161
162
162
#define IFLA_VTI_MAX (__IFLA_VTI_MAX - 1)
163
+
164
+
#define TUNNEL_CSUM __cpu_to_be16(0x01)
165
+
#define TUNNEL_ROUTING __cpu_to_be16(0x02)
166
+
#define TUNNEL_KEY __cpu_to_be16(0x04)
167
+
#define TUNNEL_SEQ __cpu_to_be16(0x08)
168
+
#define TUNNEL_STRICT __cpu_to_be16(0x10)
169
+
#define TUNNEL_REC __cpu_to_be16(0x20)
170
+
#define TUNNEL_VERSION __cpu_to_be16(0x40)
171
+
#define TUNNEL_NO_KEY __cpu_to_be16(0x80)
172
+
#define TUNNEL_DONT_FRAGMENT __cpu_to_be16(0x0100)
173
+
#define TUNNEL_OAM __cpu_to_be16(0x0200)
174
+
#define TUNNEL_CRIT_OPT __cpu_to_be16(0x0400)
175
+
#define TUNNEL_GENEVE_OPT __cpu_to_be16(0x0800)
176
+
#define TUNNEL_VXLAN_OPT __cpu_to_be16(0x1000)
177
+
#define TUNNEL_NOCACHE __cpu_to_be16(0x2000)
178
+
#define TUNNEL_ERSPAN_OPT __cpu_to_be16(0x4000)
179
+
180
+
#define TUNNEL_OPTIONS_PRESENT \
181
+
(TUNNEL_GENEVE_OPT | TUNNEL_VXLAN_OPT | TUNNEL_ERSPAN_OPT)
182
+
163
183
#endif /* _UAPI_IF_TUNNEL_H_ */
+7
-3
include/uapi/linux/in.h
+7
-3
include/uapi/linux/in.h
···
266
266
267
267
#define IN_CLASSD(a) ((((long int) (a)) & 0xf0000000) == 0xe0000000)
268
268
#define IN_MULTICAST(a) IN_CLASSD(a)
269
-
#define IN_MULTICAST_NET 0xF0000000
269
+
#define IN_MULTICAST_NET 0xe0000000
270
270
271
-
#define IN_EXPERIMENTAL(a) ((((long int) (a)) & 0xf0000000) == 0xf0000000)
272
-
#define IN_BADCLASS(a) IN_EXPERIMENTAL((a))
271
+
#define IN_BADCLASS(a) ((((long int) (a) ) == 0xffffffff)
272
+
#define IN_EXPERIMENTAL(a) IN_BADCLASS((a))
273
+
274
+
#define IN_CLASSE(a) ((((long int) (a)) & 0xf0000000) == 0xf0000000)
275
+
#define IN_CLASSE_NET 0xffffffff
276
+
#define IN_CLASSE_NSHIFT 0
273
277
274
278
/* Address to accept any incoming messages. */
275
279
#define INADDR_ANY ((unsigned long int) 0x00000000)
+2
-2
include/uapi/linux/net_tstamp.h
+2
-2
include/uapi/linux/net_tstamp.h
···
155
155
};
156
156
157
157
struct sock_txtime {
158
-
clockid_t clockid; /* reference clockid */
159
-
__u32 flags; /* as defined by enum txtime_flags */
158
+
__kernel_clockid_t clockid;/* reference clockid */
159
+
__u32 flags; /* as defined by enum txtime_flags */
160
160
};
161
161
162
162
#endif /* _NET_TIMESTAMPING_H */
+1
-1
include/uapi/linux/netlink.h
+1
-1
include/uapi/linux/netlink.h
+15
-6
kernel/bpf/core.c
+15
-6
kernel/bpf/core.c
···
365
365
}
366
366
367
367
#ifdef CONFIG_BPF_JIT
368
-
# define BPF_JIT_LIMIT_DEFAULT (PAGE_SIZE * 40000)
369
-
370
368
/* All BPF JIT sysctl knobs here. */
371
369
int bpf_jit_enable __read_mostly = IS_BUILTIN(CONFIG_BPF_JIT_ALWAYS_ON);
372
370
int bpf_jit_harden __read_mostly;
373
371
int bpf_jit_kallsyms __read_mostly;
374
-
int bpf_jit_limit __read_mostly = BPF_JIT_LIMIT_DEFAULT;
372
+
long bpf_jit_limit __read_mostly;
375
373
376
374
static __always_inline void
377
375
bpf_get_prog_addr_region(const struct bpf_prog *prog,
···
578
580
579
581
static atomic_long_t bpf_jit_current;
580
582
583
+
/* Can be overridden by an arch's JIT compiler if it has a custom,
584
+
* dedicated BPF backend memory area, or if neither of the two
585
+
* below apply.
586
+
*/
587
+
u64 __weak bpf_jit_alloc_exec_limit(void)
588
+
{
581
589
#if defined(MODULES_VADDR)
590
+
return MODULES_END - MODULES_VADDR;
591
+
#else
592
+
return VMALLOC_END - VMALLOC_START;
593
+
#endif
594
+
}
595
+
582
596
static int __init bpf_jit_charge_init(void)
583
597
{
584
598
/* Only used as heuristic here to derive limit. */
585
-
bpf_jit_limit = min_t(u64, round_up((MODULES_END - MODULES_VADDR) >> 2,
586
-
PAGE_SIZE), INT_MAX);
599
+
bpf_jit_limit = min_t(u64, round_up(bpf_jit_alloc_exec_limit() >> 2,
600
+
PAGE_SIZE), LONG_MAX);
587
601
return 0;
588
602
}
589
603
pure_initcall(bpf_jit_charge_init);
590
-
#endif
591
604
592
605
static int bpf_jit_charge_modmem(u32 pages)
593
606
{
+10
-3
kernel/bpf/verifier.c
+10
-3
kernel/bpf/verifier.c
···
5102
5102
}
5103
5103
new_sl->next = env->explored_states[insn_idx];
5104
5104
env->explored_states[insn_idx] = new_sl;
5105
-
/* connect new state to parentage chain */
5106
-
for (i = 0; i < BPF_REG_FP; i++)
5107
-
cur_regs(env)[i].parent = &new->frame[new->curframe]->regs[i];
5105
+
/* connect new state to parentage chain. Current frame needs all
5106
+
* registers connected. Only r6 - r9 of the callers are alive (pushed
5107
+
* to the stack implicitly by JITs) so in callers' frames connect just
5108
+
* r6 - r9 as an optimization. Callers will have r1 - r5 connected to
5109
+
* the state of the call instruction (with WRITTEN set), and r0 comes
5110
+
* from callee with its full parentage chain, anyway.
5111
+
*/
5112
+
for (j = 0; j <= cur->curframe; j++)
5113
+
for (i = j < cur->curframe ? BPF_REG_6 : 0; i < BPF_REG_FP; i++)
5114
+
cur->frame[j]->regs[i].parent = &new->frame[j]->regs[i];
5108
5115
/* clear write marks in current state: the writes we did are not writes
5109
5116
* our child did, so they don't screen off its reads from us.
5110
5117
* (There are no read marks in current state, because reads always mark
+1
-1
net/can/raw.c
+1
-1
net/can/raw.c
+5
-1
net/core/flow_dissector.c
+5
-1
net/core/flow_dissector.c
···
783
783
/* Pass parameters to the BPF program */
784
784
cb->qdisc_cb.flow_keys = &flow_keys;
785
785
flow_keys.nhoff = nhoff;
786
+
flow_keys.thoff = nhoff;
786
787
787
788
bpf_compute_data_pointers((struct sk_buff *)skb);
788
789
result = BPF_PROG_RUN(attached, skb);
···
791
790
/* Restore state */
792
791
memcpy(cb, &cb_saved, sizeof(cb_saved));
793
792
793
+
flow_keys.nhoff = clamp_t(u16, flow_keys.nhoff, 0, skb->len);
794
+
flow_keys.thoff = clamp_t(u16, flow_keys.thoff,
795
+
flow_keys.nhoff, skb->len);
796
+
794
797
__skb_flow_bpf_to_target(&flow_keys, flow_dissector,
795
798
target_container);
796
-
key_control->thoff = min_t(u16, key_control->thoff, skb->len);
797
799
rcu_read_unlock();
798
800
return result == BPF_OK;
799
801
}
+1
net/core/gro_cells.c
+1
net/core/gro_cells.c
+6
-1
net/core/neighbour.c
+6
-1
net/core/neighbour.c
···
2494
2494
2495
2495
ndm = nlmsg_data(nlh);
2496
2496
if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_ifindex ||
2497
-
ndm->ndm_state || ndm->ndm_flags || ndm->ndm_type) {
2497
+
ndm->ndm_state || ndm->ndm_type) {
2498
2498
NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor dump request");
2499
+
return -EINVAL;
2500
+
}
2501
+
2502
+
if (ndm->ndm_flags & ~NTF_PROXY) {
2503
+
NL_SET_ERR_MSG(extack, "Invalid flags in header for neighbor dump request");
2499
2504
return -EINVAL;
2500
2505
}
2501
2506
+17
-3
net/core/sysctl_net_core.c
+17
-3
net/core/sysctl_net_core.c
···
28
28
static int min_sndbuf = SOCK_MIN_SNDBUF;
29
29
static int min_rcvbuf = SOCK_MIN_RCVBUF;
30
30
static int max_skb_frags = MAX_SKB_FRAGS;
31
+
static long long_one __maybe_unused = 1;
32
+
static long long_max __maybe_unused = LONG_MAX;
31
33
32
34
static int net_msg_warn; /* Unused, but still a sysctl */
33
35
···
291
289
292
290
return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
293
291
}
292
+
293
+
static int
294
+
proc_dolongvec_minmax_bpf_restricted(struct ctl_table *table, int write,
295
+
void __user *buffer, size_t *lenp,
296
+
loff_t *ppos)
297
+
{
298
+
if (!capable(CAP_SYS_ADMIN))
299
+
return -EPERM;
300
+
301
+
return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
302
+
}
294
303
#endif
295
304
296
305
static struct ctl_table net_core_table[] = {
···
411
398
{
412
399
.procname = "bpf_jit_limit",
413
400
.data = &bpf_jit_limit,
414
-
.maxlen = sizeof(int),
401
+
.maxlen = sizeof(long),
415
402
.mode = 0600,
416
-
.proc_handler = proc_dointvec_minmax_bpf_restricted,
417
-
.extra1 = &one,
403
+
.proc_handler = proc_dolongvec_minmax_bpf_restricted,
404
+
.extra1 = &long_one,
405
+
.extra2 = &long_max,
418
406
},
419
407
#endif
420
408
{
+3
-2
net/ipv4/devinet.c
+3
-2
net/ipv4/devinet.c
···
952
952
{
953
953
int rc = -1; /* Something else, probably a multicast. */
954
954
955
-
if (ipv4_is_zeronet(addr))
955
+
if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
956
956
rc = 0;
957
957
else {
958
958
__u32 haddr = ntohl(addr);
959
-
960
959
if (IN_CLASSA(haddr))
961
960
rc = 8;
962
961
else if (IN_CLASSB(haddr))
963
962
rc = 16;
964
963
else if (IN_CLASSC(haddr))
965
964
rc = 24;
965
+
else if (IN_CLASSE(haddr))
966
+
rc = 32;
966
967
}
967
968
968
969
return rc;
+1
net/ipv4/ip_forward.c
+1
net/ipv4/ip_forward.c
+12
-6
net/ipv4/ip_fragment.c
+12
-6
net/ipv4/ip_fragment.c
···
346
346
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
347
347
struct rb_node **rbn, *parent;
348
348
struct sk_buff *skb1, *prev_tail;
349
+
int ihl, end, skb1_run_end;
349
350
struct net_device *dev;
350
351
unsigned int fragsize;
351
352
int flags, offset;
352
-
int ihl, end;
353
353
int err = -ENOENT;
354
354
u8 ecn;
355
355
···
419
419
* overlapping fragment, the entire datagram (and any constituent
420
420
* fragments) MUST be silently discarded.
421
421
*
422
-
* We do the same here for IPv4 (and increment an snmp counter).
422
+
* We do the same here for IPv4 (and increment an snmp counter) but
423
+
* we do not want to drop the whole queue in response to a duplicate
424
+
* fragment.
423
425
*/
424
426
425
427
err = -EINVAL;
···
446
444
do {
447
445
parent = *rbn;
448
446
skb1 = rb_to_skb(parent);
447
+
skb1_run_end = skb1->ip_defrag_offset +
448
+
FRAG_CB(skb1)->frag_run_len;
449
449
if (end <= skb1->ip_defrag_offset)
450
450
rbn = &parent->rb_left;
451
-
else if (offset >= skb1->ip_defrag_offset +
452
-
FRAG_CB(skb1)->frag_run_len)
451
+
else if (offset >= skb1_run_end)
453
452
rbn = &parent->rb_right;
454
-
else /* Found an overlap with skb1. */
455
-
goto overlap;
453
+
else if (offset >= skb1->ip_defrag_offset &&
454
+
end <= skb1_run_end)
455
+
goto err; /* No new data, potential duplicate */
456
+
else
457
+
goto overlap; /* Found an overlap */
456
458
} while (*rbn);
457
459
/* Here we have parent properly set, and rbn pointing to
458
460
* one of its NULL left/right children. Insert skb.
+2
net/ipv4/ipconfig.c
+2
net/ipv4/ipconfig.c
···
429
429
ic_netmask = htonl(IN_CLASSB_NET);
430
430
else if (IN_CLASSC(ntohl(ic_myaddr)))
431
431
ic_netmask = htonl(IN_CLASSC_NET);
432
+
else if (IN_CLASSE(ntohl(ic_myaddr)))
433
+
ic_netmask = htonl(IN_CLASSE_NET);
432
434
else {
433
435
pr_err("IP-Config: Unable to guess netmask for address %pI4\n",
434
436
&ic_myaddr);
+4
net/ipv4/ipmr.c
+4
net/ipv4/ipmr.c
···
69
69
#include <net/nexthop.h>
70
70
#include <net/switchdev.h>
71
71
72
+
#include <linux/nospec.h>
73
+
72
74
struct ipmr_rule {
73
75
struct fib_rule common;
74
76
};
···
1614
1612
return -EFAULT;
1615
1613
if (vr.vifi >= mrt->maxvif)
1616
1614
return -EINVAL;
1615
+
vr.vifi = array_index_nospec(vr.vifi, mrt->maxvif);
1617
1616
read_lock(&mrt_lock);
1618
1617
vif = &mrt->vif_table[vr.vifi];
1619
1618
if (VIF_EXISTS(mrt, vr.vifi)) {
···
1689
1686
return -EFAULT;
1690
1687
if (vr.vifi >= mrt->maxvif)
1691
1688
return -EINVAL;
1689
+
vr.vifi = array_index_nospec(vr.vifi, mrt->maxvif);
1692
1690
read_lock(&mrt_lock);
1693
1691
vif = &mrt->vif_table[vr.vifi];
1694
1692
if (VIF_EXISTS(mrt, vr.vifi)) {
+1
-1
net/ipv4/raw.c
+1
-1
net/ipv4/raw.c
+1
net/ipv6/ip6_output.c
+1
net/ipv6/ip6_output.c
+2
-1
net/ipv6/ip6_udp_tunnel.c
+2
-1
net/ipv6/ip6_udp_tunnel.c
···
15
15
int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg,
16
16
struct socket **sockp)
17
17
{
18
-
struct sockaddr_in6 udp6_addr;
18
+
struct sockaddr_in6 udp6_addr = {};
19
19
int err;
20
20
struct socket *sock = NULL;
21
21
···
42
42
goto error;
43
43
44
44
if (cfg->peer_udp_port) {
45
+
memset(&udp6_addr, 0, sizeof(udp6_addr));
45
46
udp6_addr.sin6_family = AF_INET6;
46
47
memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
47
48
sizeof(udp6_addr.sin6_addr));
+4
net/ipv6/ip6mr.c
+4
net/ipv6/ip6mr.c
···
52
52
#include <net/ip6_checksum.h>
53
53
#include <linux/netconf.h>
54
54
55
+
#include <linux/nospec.h>
56
+
55
57
struct ip6mr_rule {
56
58
struct fib_rule common;
57
59
};
···
1843
1841
return -EFAULT;
1844
1842
if (vr.mifi >= mrt->maxvif)
1845
1843
return -EINVAL;
1844
+
vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1846
1845
read_lock(&mrt_lock);
1847
1846
vif = &mrt->vif_table[vr.mifi];
1848
1847
if (VIF_EXISTS(mrt, vr.mifi)) {
···
1918
1915
return -EFAULT;
1919
1916
if (vr.mifi >= mrt->maxvif)
1920
1917
return -EINVAL;
1918
+
vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1921
1919
read_lock(&mrt_lock);
1922
1920
vif = &mrt->vif_table[vr.mifi];
1923
1921
if (VIF_EXISTS(mrt, vr.mifi)) {
+2
net/ipv6/raw.c
+2
net/ipv6/raw.c
+3
net/mac80211/iface.c
+3
net/mac80211/iface.c
···
7
7
* Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
8
8
* Copyright 2013-2014 Intel Mobile Communications GmbH
9
9
* Copyright (c) 2016 Intel Deutschland GmbH
10
+
* Copyright (C) 2018 Intel Corporation
10
11
*
11
12
* This program is free software; you can redistribute it and/or modify
12
13
* it under the terms of the GNU General Public License version 2 as
···
1951
1950
1952
1951
WARN(local->open_count, "%s: open count remains %d\n",
1953
1952
wiphy_name(local->hw.wiphy), local->open_count);
1953
+
1954
+
ieee80211_txq_teardown_flows(local);
1954
1955
1955
1956
mutex_lock(&local->iflist_mtx);
1956
1957
list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
-2
net/mac80211/main.c
-2
net/mac80211/main.c
···
1262
1262
rtnl_unlock();
1263
1263
ieee80211_led_exit(local);
1264
1264
ieee80211_wep_free(local);
1265
-
ieee80211_txq_teardown_flows(local);
1266
1265
fail_flows:
1267
1266
destroy_workqueue(local->workqueue);
1268
1267
fail_workqueue:
···
1287
1288
#if IS_ENABLED(CONFIG_IPV6)
1288
1289
unregister_inet6addr_notifier(&local->ifa6_notifier);
1289
1290
#endif
1290
-
ieee80211_txq_teardown_flows(local);
1291
1291
1292
1292
rtnl_lock();
1293
1293
+5
net/mac80211/status.c
+5
net/mac80211/status.c
+1
-1
net/netfilter/ipset/ip_set_list_set.c
+1
-1
net/netfilter/ipset/ip_set_list_set.c
+1
-1
net/netfilter/nf_conncount.c
+1
-1
net/netfilter/nf_conncount.c
···
427
427
count = 1;
428
428
rbconn->list.count = count;
429
429
430
-
rb_link_node(&rbconn->node, parent, rbnode);
430
+
rb_link_node_rcu(&rbconn->node, parent, rbnode);
431
431
rb_insert_color(&rbconn->node, root);
432
432
out_unlock:
433
433
spin_unlock_bh(&nf_conncount_locks[hash % CONNCOUNT_LOCK_SLOTS]);
+4
-3
net/netfilter/nf_conntrack_seqadj.c
+4
-3
net/netfilter/nf_conntrack_seqadj.c
···
115
115
/* TCP SACK sequence number adjustment */
116
116
static unsigned int nf_ct_sack_adjust(struct sk_buff *skb,
117
117
unsigned int protoff,
118
-
struct tcphdr *tcph,
119
118
struct nf_conn *ct,
120
119
enum ip_conntrack_info ctinfo)
121
120
{
122
-
unsigned int dir, optoff, optend;
121
+
struct tcphdr *tcph = (void *)skb->data + protoff;
123
122
struct nf_conn_seqadj *seqadj = nfct_seqadj(ct);
123
+
unsigned int dir, optoff, optend;
124
124
125
125
optoff = protoff + sizeof(struct tcphdr);
126
126
optend = protoff + tcph->doff * 4;
···
128
128
if (!skb_make_writable(skb, optend))
129
129
return 0;
130
130
131
+
tcph = (void *)skb->data + protoff;
131
132
dir = CTINFO2DIR(ctinfo);
132
133
133
134
while (optoff < optend) {
···
208
207
ntohl(newack));
209
208
tcph->ack_seq = newack;
210
209
211
-
res = nf_ct_sack_adjust(skb, protoff, tcph, ct, ctinfo);
210
+
res = nf_ct_sack_adjust(skb, protoff, ct, ctinfo);
212
211
out:
213
212
spin_unlock_bh(&ct->lock);
214
213
+2
-1
net/netfilter/nf_nat_core.c
+2
-1
net/netfilter/nf_nat_core.c
+13
-8
net/netfilter/nf_tables_api.c
+13
-8
net/netfilter/nf_tables_api.c
···
1216
1216
if (nla_put_string(skb, NFTA_CHAIN_TYPE, basechain->type->name))
1217
1217
goto nla_put_failure;
1218
1218
1219
-
if (basechain->stats && nft_dump_stats(skb, basechain->stats))
1219
+
if (rcu_access_pointer(basechain->stats) &&
1220
+
nft_dump_stats(skb, rcu_dereference(basechain->stats)))
1220
1221
goto nla_put_failure;
1221
1222
}
1222
1223
···
1393
1392
return newstats;
1394
1393
}
1395
1394
1396
-
static void nft_chain_stats_replace(struct nft_base_chain *chain,
1395
+
static void nft_chain_stats_replace(struct net *net,
1396
+
struct nft_base_chain *chain,
1397
1397
struct nft_stats __percpu *newstats)
1398
1398
{
1399
1399
struct nft_stats __percpu *oldstats;
···
1402
1400
if (newstats == NULL)
1403
1401
return;
1404
1402
1405
-
if (chain->stats) {
1406
-
oldstats = nfnl_dereference(chain->stats, NFNL_SUBSYS_NFTABLES);
1403
+
if (rcu_access_pointer(chain->stats)) {
1404
+
oldstats = rcu_dereference_protected(chain->stats,
1405
+
lockdep_commit_lock_is_held(net));
1407
1406
rcu_assign_pointer(chain->stats, newstats);
1408
1407
synchronize_rcu();
1409
1408
free_percpu(oldstats);
···
1442
1439
struct nft_base_chain *basechain = nft_base_chain(chain);
1443
1440
1444
1441
module_put(basechain->type->owner);
1445
-
free_percpu(basechain->stats);
1446
-
if (basechain->stats)
1442
+
if (rcu_access_pointer(basechain->stats)) {
1447
1443
static_branch_dec(&nft_counters_enabled);
1444
+
free_percpu(rcu_dereference_raw(basechain->stats));
1445
+
}
1448
1446
kfree(chain->name);
1449
1447
kfree(basechain);
1450
1448
} else {
···
1594
1590
kfree(basechain);
1595
1591
return PTR_ERR(stats);
1596
1592
}
1597
-
basechain->stats = stats;
1593
+
rcu_assign_pointer(basechain->stats, stats);
1598
1594
static_branch_inc(&nft_counters_enabled);
1599
1595
}
1600
1596
···
6184
6180
return;
6185
6181
6186
6182
basechain = nft_base_chain(trans->ctx.chain);
6187
-
nft_chain_stats_replace(basechain, nft_trans_chain_stats(trans));
6183
+
nft_chain_stats_replace(trans->ctx.net, basechain,
6184
+
nft_trans_chain_stats(trans));
6188
6185
6189
6186
switch (nft_trans_chain_policy(trans)) {
6190
6187
case NF_DROP:
+1
-1
net/netfilter/nf_tables_core.c
+1
-1
net/netfilter/nf_tables_core.c
+2
-2
net/netlink/af_netlink.c
+2
-2
net/netlink/af_netlink.c
···
1706
1706
nlk->flags &= ~NETLINK_F_EXT_ACK;
1707
1707
err = 0;
1708
1708
break;
1709
-
case NETLINK_DUMP_STRICT_CHK:
1709
+
case NETLINK_GET_STRICT_CHK:
1710
1710
if (val)
1711
1711
nlk->flags |= NETLINK_F_STRICT_CHK;
1712
1712
else
···
1806
1806
return -EFAULT;
1807
1807
err = 0;
1808
1808
break;
1809
-
case NETLINK_DUMP_STRICT_CHK:
1809
+
case NETLINK_GET_STRICT_CHK:
1810
1810
if (len < sizeof(int))
1811
1811
return -EINVAL;
1812
1812
len = sizeof(int);
+3
-3
net/packet/af_packet.c
+3
-3
net/packet/af_packet.c
···
1965
1965
skb->mark = sk->sk_mark;
1966
1966
skb->tstamp = sockc.transmit_time;
1967
1967
1968
-
sock_tx_timestamp(sk, sockc.tsflags, &skb_shinfo(skb)->tx_flags);
1968
+
skb_setup_tx_timestamp(skb, sockc.tsflags);
1969
1969
1970
1970
if (unlikely(extra_len == 4))
1971
1971
skb->no_fcs = 1;
···
2460
2460
skb->priority = po->sk.sk_priority;
2461
2461
skb->mark = po->sk.sk_mark;
2462
2462
skb->tstamp = sockc->transmit_time;
2463
-
sock_tx_timestamp(&po->sk, sockc->tsflags, &skb_shinfo(skb)->tx_flags);
2463
+
skb_setup_tx_timestamp(skb, sockc->tsflags);
2464
2464
skb_zcopy_set_nouarg(skb, ph.raw);
2465
2465
2466
2466
skb_reserve(skb, hlen);
···
2898
2898
goto out_free;
2899
2899
}
2900
2900
2901
-
sock_tx_timestamp(sk, sockc.tsflags, &skb_shinfo(skb)->tx_flags);
2901
+
skb_setup_tx_timestamp(skb, sockc.tsflags);
2902
2902
2903
2903
if (!vnet_hdr.gso_type && (len > dev->mtu + reserve + extra_len) &&
2904
2904
!packet_extra_vlan_len_allowed(dev, skb)) {
+19
-7
net/rds/message.c
+19
-7
net/rds/message.c
···
308
308
/*
309
309
* RDS ops use this to grab SG entries from the rm's sg pool.
310
310
*/
311
-
struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents)
311
+
struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents,
312
+
int *ret)
312
313
{
313
314
struct scatterlist *sg_first = (struct scatterlist *) &rm[1];
314
315
struct scatterlist *sg_ret;
315
316
316
-
WARN_ON(rm->m_used_sgs + nents > rm->m_total_sgs);
317
-
WARN_ON(!nents);
318
-
319
-
if (rm->m_used_sgs + nents > rm->m_total_sgs)
317
+
if (WARN_ON(!ret))
320
318
return NULL;
319
+
320
+
if (nents <= 0) {
321
+
pr_warn("rds: alloc sgs failed! nents <= 0\n");
322
+
*ret = -EINVAL;
323
+
return NULL;
324
+
}
325
+
326
+
if (rm->m_used_sgs + nents > rm->m_total_sgs) {
327
+
pr_warn("rds: alloc sgs failed! total %d used %d nents %d\n",
328
+
rm->m_total_sgs, rm->m_used_sgs, nents);
329
+
*ret = -ENOMEM;
330
+
return NULL;
331
+
}
321
332
322
333
sg_ret = &sg_first[rm->m_used_sgs];
323
334
sg_init_table(sg_ret, nents);
···
343
332
unsigned int i;
344
333
int num_sgs = ceil(total_len, PAGE_SIZE);
345
334
int extra_bytes = num_sgs * sizeof(struct scatterlist);
335
+
int ret;
346
336
347
337
rm = rds_message_alloc(extra_bytes, GFP_NOWAIT);
348
338
if (!rm)
···
352
340
set_bit(RDS_MSG_PAGEVEC, &rm->m_flags);
353
341
rm->m_inc.i_hdr.h_len = cpu_to_be32(total_len);
354
342
rm->data.op_nents = ceil(total_len, PAGE_SIZE);
355
-
rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs);
343
+
rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs, &ret);
356
344
if (!rm->data.op_sg) {
357
345
rds_message_put(rm);
358
-
return ERR_PTR(-ENOMEM);
346
+
return ERR_PTR(ret);
359
347
}
360
348
361
349
for (i = 0; i < rm->data.op_nents; ++i) {
+37
-40
net/rds/rdma.c
+37
-40
net/rds/rdma.c
···
517
517
return tot_pages;
518
518
}
519
519
520
-
int rds_rdma_extra_size(struct rds_rdma_args *args)
520
+
int rds_rdma_extra_size(struct rds_rdma_args *args,
521
+
struct rds_iov_vector *iov)
521
522
{
522
-
struct rds_iovec vec;
523
+
struct rds_iovec *vec;
523
524
struct rds_iovec __user *local_vec;
524
525
int tot_pages = 0;
525
526
unsigned int nr_pages;
···
531
530
if (args->nr_local == 0)
532
531
return -EINVAL;
533
532
534
-
/* figure out the number of pages in the vector */
535
-
for (i = 0; i < args->nr_local; i++) {
536
-
if (copy_from_user(&vec, &local_vec[i],
537
-
sizeof(struct rds_iovec)))
538
-
return -EFAULT;
533
+
iov->iov = kcalloc(args->nr_local,
534
+
sizeof(struct rds_iovec),
535
+
GFP_KERNEL);
536
+
if (!iov->iov)
537
+
return -ENOMEM;
539
538
540
-
nr_pages = rds_pages_in_vec(&vec);
539
+
vec = &iov->iov[0];
540
+
541
+
if (copy_from_user(vec, local_vec, args->nr_local *
542
+
sizeof(struct rds_iovec)))
543
+
return -EFAULT;
544
+
iov->len = args->nr_local;
545
+
546
+
/* figure out the number of pages in the vector */
547
+
for (i = 0; i < args->nr_local; i++, vec++) {
548
+
549
+
nr_pages = rds_pages_in_vec(vec);
541
550
if (nr_pages == 0)
542
551
return -EINVAL;
543
552
···
569
558
* Extract all arguments and set up the rdma_op
570
559
*/
571
560
int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
572
-
struct cmsghdr *cmsg)
561
+
struct cmsghdr *cmsg,
562
+
struct rds_iov_vector *vec)
573
563
{
574
564
struct rds_rdma_args *args;
575
565
struct rm_rdma_op *op = &rm->rdma;
576
566
int nr_pages;
577
567
unsigned int nr_bytes;
578
568
struct page **pages = NULL;
579
-
struct rds_iovec iovstack[UIO_FASTIOV], *iovs = iovstack;
580
-
int iov_size;
569
+
struct rds_iovec *iovs;
581
570
unsigned int i, j;
582
571
int ret = 0;
583
572
···
597
586
goto out_ret;
598
587
}
599
588
600
-
/* Check whether to allocate the iovec area */
601
-
iov_size = args->nr_local * sizeof(struct rds_iovec);
602
-
if (args->nr_local > UIO_FASTIOV) {
603
-
iovs = sock_kmalloc(rds_rs_to_sk(rs), iov_size, GFP_KERNEL);
604
-
if (!iovs) {
605
-
ret = -ENOMEM;
606
-
goto out_ret;
607
-
}
589
+
if (vec->len != args->nr_local) {
590
+
ret = -EINVAL;
591
+
goto out_ret;
608
592
}
609
593
610
-
if (copy_from_user(iovs, (struct rds_iovec __user *)(unsigned long) args->local_vec_addr, iov_size)) {
611
-
ret = -EFAULT;
612
-
goto out;
613
-
}
594
+
iovs = vec->iov;
614
595
615
596
nr_pages = rds_rdma_pages(iovs, args->nr_local);
616
597
if (nr_pages < 0) {
617
598
ret = -EINVAL;
618
-
goto out;
599
+
goto out_ret;
619
600
}
620
601
621
602
pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
622
603
if (!pages) {
623
604
ret = -ENOMEM;
624
-
goto out;
605
+
goto out_ret;
625
606
}
626
607
627
608
op->op_write = !!(args->flags & RDS_RDMA_READWRITE);
···
623
620
op->op_active = 1;
624
621
op->op_recverr = rs->rs_recverr;
625
622
WARN_ON(!nr_pages);
626
-
op->op_sg = rds_message_alloc_sgs(rm, nr_pages);
627
-
if (!op->op_sg) {
628
-
ret = -ENOMEM;
629
-
goto out;
630
-
}
623
+
op->op_sg = rds_message_alloc_sgs(rm, nr_pages, &ret);
624
+
if (!op->op_sg)
625
+
goto out_pages;
631
626
632
627
if (op->op_notify || op->op_recverr) {
633
628
/* We allocate an uninitialized notifier here, because
···
636
635
op->op_notifier = kmalloc(sizeof(struct rds_notifier), GFP_KERNEL);
637
636
if (!op->op_notifier) {
638
637
ret = -ENOMEM;
639
-
goto out;
638
+
goto out_pages;
640
639
}
641
640
op->op_notifier->n_user_token = args->user_token;
642
641
op->op_notifier->n_status = RDS_RDMA_SUCCESS;
···
682
681
*/
683
682
ret = rds_pin_pages(iov->addr, nr, pages, !op->op_write);
684
683
if (ret < 0)
685
-
goto out;
684
+
goto out_pages;
686
685
else
687
686
ret = 0;
688
687
···
715
714
nr_bytes,
716
715
(unsigned int) args->remote_vec.bytes);
717
716
ret = -EINVAL;
718
-
goto out;
717
+
goto out_pages;
719
718
}
720
719
op->op_bytes = nr_bytes;
721
720
722
-
out:
723
-
if (iovs != iovstack)
724
-
sock_kfree_s(rds_rs_to_sk(rs), iovs, iov_size);
721
+
out_pages:
725
722
kfree(pages);
726
723
out_ret:
727
724
if (ret)
···
837
838
rm->atomic.op_silent = !!(args->flags & RDS_RDMA_SILENT);
838
839
rm->atomic.op_active = 1;
839
840
rm->atomic.op_recverr = rs->rs_recverr;
840
-
rm->atomic.op_sg = rds_message_alloc_sgs(rm, 1);
841
-
if (!rm->atomic.op_sg) {
842
-
ret = -ENOMEM;
841
+
rm->atomic.op_sg = rds_message_alloc_sgs(rm, 1, &ret);
842
+
if (!rm->atomic.op_sg)
843
843
goto err;
844
-
}
845
844
846
845
/* verify 8 byte-aligned */
847
846
if (args->local_addr & 0x7) {
+18
-5
net/rds/rds.h
+18
-5
net/rds/rds.h
···
386
386
INIT_LIST_HEAD(&q->zcookie_head);
387
387
}
388
388
389
+
struct rds_iov_vector {
390
+
struct rds_iovec *iov;
391
+
int len;
392
+
};
393
+
394
+
struct rds_iov_vector_arr {
395
+
struct rds_iov_vector *vec;
396
+
int len;
397
+
int indx;
398
+
int incr;
399
+
};
400
+
389
401
struct rds_message {
390
402
refcount_t m_refcount;
391
403
struct list_head m_sock_item;
···
839
827
840
828
/* message.c */
841
829
struct rds_message *rds_message_alloc(unsigned int nents, gfp_t gfp);
842
-
struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents);
830
+
struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents,
831
+
int *ret);
843
832
int rds_message_copy_from_user(struct rds_message *rm, struct iov_iter *from,
844
833
bool zcopy);
845
834
struct rds_message *rds_message_map_pages(unsigned long *page_addrs, unsigned int total_len);
···
917
904
int rds_get_mr_for_dest(struct rds_sock *rs, char __user *optval, int optlen);
918
905
int rds_free_mr(struct rds_sock *rs, char __user *optval, int optlen);
919
906
void rds_rdma_drop_keys(struct rds_sock *rs);
920
-
int rds_rdma_extra_size(struct rds_rdma_args *args);
921
-
int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
922
-
struct cmsghdr *cmsg);
907
+
int rds_rdma_extra_size(struct rds_rdma_args *args,
908
+
struct rds_iov_vector *iov);
923
909
int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
924
910
struct cmsghdr *cmsg);
925
911
int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
926
-
struct cmsghdr *cmsg);
912
+
struct cmsghdr *cmsg,
913
+
struct rds_iov_vector *vec);
927
914
int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm,
928
915
struct cmsghdr *cmsg);
929
916
void rds_rdma_free_op(struct rm_rdma_op *ro);
+50
-11
net/rds/send.c
+50
-11
net/rds/send.c
···
876
876
* rds_message is getting to be quite complicated, and we'd like to allocate
877
877
* it all in one go. This figures out how big it needs to be up front.
878
878
*/
879
-
static int rds_rm_size(struct msghdr *msg, int num_sgs)
879
+
static int rds_rm_size(struct msghdr *msg, int num_sgs,
880
+
struct rds_iov_vector_arr *vct)
880
881
{
881
882
struct cmsghdr *cmsg;
882
883
int size = 0;
883
884
int cmsg_groups = 0;
884
885
int retval;
885
886
bool zcopy_cookie = false;
887
+
struct rds_iov_vector *iov, *tmp_iov;
888
+
889
+
if (num_sgs < 0)
890
+
return -EINVAL;
886
891
887
892
for_each_cmsghdr(cmsg, msg) {
888
893
if (!CMSG_OK(msg, cmsg))
···
898
893
899
894
switch (cmsg->cmsg_type) {
900
895
case RDS_CMSG_RDMA_ARGS:
896
+
if (vct->indx >= vct->len) {
897
+
vct->len += vct->incr;
898
+
tmp_iov =
899
+
krealloc(vct->vec,
900
+
vct->len *
901
+
sizeof(struct rds_iov_vector),
902
+
GFP_KERNEL);
903
+
if (!tmp_iov) {
904
+
vct->len -= vct->incr;
905
+
return -ENOMEM;
906
+
}
907
+
vct->vec = tmp_iov;
908
+
}
909
+
iov = &vct->vec[vct->indx];
910
+
memset(iov, 0, sizeof(struct rds_iov_vector));
911
+
vct->indx++;
901
912
cmsg_groups |= 1;
902
-
retval = rds_rdma_extra_size(CMSG_DATA(cmsg));
913
+
retval = rds_rdma_extra_size(CMSG_DATA(cmsg), iov);
903
914
if (retval < 0)
904
915
return retval;
905
916
size += retval;
···
972
951
}
973
952
974
953
static int rds_cmsg_send(struct rds_sock *rs, struct rds_message *rm,
975
-
struct msghdr *msg, int *allocated_mr)
954
+
struct msghdr *msg, int *allocated_mr,
955
+
struct rds_iov_vector_arr *vct)
976
956
{
977
957
struct cmsghdr *cmsg;
978
-
int ret = 0;
958
+
int ret = 0, ind = 0;
979
959
980
960
for_each_cmsghdr(cmsg, msg) {
981
961
if (!CMSG_OK(msg, cmsg))
···
990
968
*/
991
969
switch (cmsg->cmsg_type) {
992
970
case RDS_CMSG_RDMA_ARGS:
993
-
ret = rds_cmsg_rdma_args(rs, rm, cmsg);
971
+
if (ind >= vct->indx)
972
+
return -ENOMEM;
973
+
ret = rds_cmsg_rdma_args(rs, rm, cmsg, &vct->vec[ind]);
974
+
ind++;
994
975
break;
995
976
996
977
case RDS_CMSG_RDMA_DEST:
···
1109
1084
sock_flag(rds_rs_to_sk(rs), SOCK_ZEROCOPY));
1110
1085
int num_sgs = ceil(payload_len, PAGE_SIZE);
1111
1086
int namelen;
1087
+
struct rds_iov_vector_arr vct;
1088
+
int ind;
1089
+
1090
+
memset(&vct, 0, sizeof(vct));
1091
+
1092
+
/* expect 1 RDMA CMSG per rds_sendmsg. can still grow if more needed. */
1093
+
vct.incr = 1;
1112
1094
1113
1095
/* Mirror Linux UDP mirror of BSD error message compatibility */
1114
1096
/* XXX: Perhaps MSG_MORE someday */
···
1252
1220
num_sgs = iov_iter_npages(&msg->msg_iter, INT_MAX);
1253
1221
}
1254
1222
/* size of rm including all sgs */
1255
-
ret = rds_rm_size(msg, num_sgs);
1223
+
ret = rds_rm_size(msg, num_sgs, &vct);
1256
1224
if (ret < 0)
1257
1225
goto out;
1258
1226
···
1264
1232
1265
1233
/* Attach data to the rm */
1266
1234
if (payload_len) {
1267
-
rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs);
1268
-
if (!rm->data.op_sg) {
1269
-
ret = -ENOMEM;
1235
+
rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs, &ret);
1236
+
if (!rm->data.op_sg)
1270
1237
goto out;
1271
-
}
1272
1238
ret = rds_message_copy_from_user(rm, &msg->msg_iter, zcopy);
1273
1239
if (ret)
1274
1240
goto out;
···
1300
1270
rm->m_conn_path = cpath;
1301
1271
1302
1272
/* Parse any control messages the user may have included. */
1303
-
ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
1273
+
ret = rds_cmsg_send(rs, rm, msg, &allocated_mr, &vct);
1304
1274
if (ret) {
1305
1275
/* Trigger connection so that its ready for the next retry */
1306
1276
if (ret == -EAGAIN)
···
1378
1348
if (ret)
1379
1349
goto out;
1380
1350
rds_message_put(rm);
1351
+
1352
+
for (ind = 0; ind < vct.indx; ind++)
1353
+
kfree(vct.vec[ind].iov);
1354
+
kfree(vct.vec);
1355
+
1381
1356
return payload_len;
1382
1357
1383
1358
out:
1359
+
for (ind = 0; ind < vct.indx; ind++)
1360
+
kfree(vct.vec[ind].iov);
1361
+
kfree(vct.vec);
1362
+
1384
1363
/* If the user included a RDMA_MAP cmsg, we allocated a MR on the fly.
1385
1364
* If the sendmsg goes through, we keep the MR. If it fails with EAGAIN
1386
1365
* or in any other way, we need to destroy the MR again */
+3
-4
net/sched/cls_flower.c
+3
-4
net/sched/cls_flower.c
···
1258
1258
fnew->flags |= TCA_CLS_FLAGS_NOT_IN_HW;
1259
1259
1260
1260
if (fold) {
1261
-
if (!tc_skip_sw(fold->flags))
1262
-
rhashtable_remove_fast(&fold->mask->ht,
1263
-
&fold->ht_node,
1264
-
fold->mask->filter_ht_params);
1261
+
rhashtable_remove_fast(&fold->mask->ht,
1262
+
&fold->ht_node,
1263
+
fold->mask->filter_ht_params);
1265
1264
if (!tc_skip_hw(fold->flags))
1266
1265
fl_hw_destroy_filter(tp, fold, NULL);
1267
1266
}
+1
net/sctp/ipv6.c
+1
net/sctp/ipv6.c
+12
-2
net/smc/af_smc.c
+12
-2
net/smc/af_smc.c
···
147
147
sk->sk_shutdown |= SHUTDOWN_MASK;
148
148
}
149
149
if (smc->clcsock) {
150
+
if (smc->use_fallback && sk->sk_state == SMC_LISTEN) {
151
+
/* wake up clcsock accept */
152
+
rc = kernel_sock_shutdown(smc->clcsock, SHUT_RDWR);
153
+
}
154
+
mutex_lock(&smc->clcsock_release_lock);
150
155
sock_release(smc->clcsock);
151
156
smc->clcsock = NULL;
157
+
mutex_unlock(&smc->clcsock_release_lock);
152
158
}
153
159
if (smc->use_fallback) {
154
160
if (sk->sk_state != SMC_LISTEN && sk->sk_state != SMC_INIT)
···
211
205
spin_lock_init(&smc->conn.send_lock);
212
206
sk->sk_prot->hash(sk);
213
207
sk_refcnt_debug_inc(sk);
208
+
mutex_init(&smc->clcsock_release_lock);
214
209
215
210
return sk;
216
211
}
···
828
821
struct socket *new_clcsock = NULL;
829
822
struct sock *lsk = &lsmc->sk;
830
823
struct sock *new_sk;
831
-
int rc;
824
+
int rc = -EINVAL;
832
825
833
826
release_sock(lsk);
834
827
new_sk = smc_sock_alloc(sock_net(lsk), NULL, lsk->sk_protocol);
···
841
834
}
842
835
*new_smc = smc_sk(new_sk);
843
836
844
-
rc = kernel_accept(lsmc->clcsock, &new_clcsock, 0);
837
+
mutex_lock(&lsmc->clcsock_release_lock);
838
+
if (lsmc->clcsock)
839
+
rc = kernel_accept(lsmc->clcsock, &new_clcsock, 0);
840
+
mutex_unlock(&lsmc->clcsock_release_lock);
845
841
lock_sock(lsk);
846
842
if (rc < 0)
847
843
lsk->sk_err = -rc;
+4
net/smc/smc.h
+4
net/smc/smc.h
+24
-16
net/tipc/socket.c
+24
-16
net/tipc/socket.c
···
880
880
DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
881
881
int blks = tsk_blocks(GROUP_H_SIZE + dlen);
882
882
struct tipc_sock *tsk = tipc_sk(sk);
883
-
struct tipc_group *grp = tsk->group;
884
883
struct net *net = sock_net(sk);
885
884
struct tipc_member *mb = NULL;
886
885
u32 node, port;
···
893
894
/* Block or return if destination link or member is congested */
894
895
rc = tipc_wait_for_cond(sock, &timeout,
895
896
!tipc_dest_find(&tsk->cong_links, node, 0) &&
896
-
!tipc_group_cong(grp, node, port, blks, &mb));
897
+
tsk->group &&
898
+
!tipc_group_cong(tsk->group, node, port, blks,
899
+
&mb));
897
900
if (unlikely(rc))
898
901
return rc;
899
902
···
925
924
struct tipc_sock *tsk = tipc_sk(sk);
926
925
struct list_head *cong_links = &tsk->cong_links;
927
926
int blks = tsk_blocks(GROUP_H_SIZE + dlen);
928
-
struct tipc_group *grp = tsk->group;
929
927
struct tipc_msg *hdr = &tsk->phdr;
930
928
struct tipc_member *first = NULL;
931
929
struct tipc_member *mbr = NULL;
···
941
941
type = msg_nametype(hdr);
942
942
inst = dest->addr.name.name.instance;
943
943
scope = msg_lookup_scope(hdr);
944
-
exclude = tipc_group_exclude(grp);
945
944
946
945
while (++lookups < 4) {
946
+
exclude = tipc_group_exclude(tsk->group);
947
+
947
948
first = NULL;
948
949
949
950
/* Look for a non-congested destination member, if any */
···
953
952
&dstcnt, exclude, false))
954
953
return -EHOSTUNREACH;
955
954
tipc_dest_pop(&dsts, &node, &port);
956
-
cong = tipc_group_cong(grp, node, port, blks, &mbr);
955
+
cong = tipc_group_cong(tsk->group, node, port, blks,
956
+
&mbr);
957
957
if (!cong)
958
958
break;
959
959
if (mbr == first)
···
973
971
/* Block or return if destination link or member is congested */
974
972
rc = tipc_wait_for_cond(sock, &timeout,
975
973
!tipc_dest_find(cong_links, node, 0) &&
976
-
!tipc_group_cong(grp, node, port,
974
+
tsk->group &&
975
+
!tipc_group_cong(tsk->group, node, port,
977
976
blks, &mbr));
978
977
if (unlikely(rc))
979
978
return rc;
···
1009
1006
struct sock *sk = sock->sk;
1010
1007
struct net *net = sock_net(sk);
1011
1008
struct tipc_sock *tsk = tipc_sk(sk);
1012
-
struct tipc_group *grp = tsk->group;
1013
-
struct tipc_nlist *dsts = tipc_group_dests(grp);
1009
+
struct tipc_nlist *dsts;
1014
1010
struct tipc_mc_method *method = &tsk->mc_method;
1015
1011
bool ack = method->mandatory && method->rcast;
1016
1012
int blks = tsk_blocks(MCAST_H_SIZE + dlen);
···
1018
1016
struct sk_buff_head pkts;
1019
1017
int rc = -EHOSTUNREACH;
1020
1018
1021
-
if (!dsts->local && !dsts->remote)
1022
-
return -EHOSTUNREACH;
1023
-
1024
1019
/* Block or return if any destination link or member is congested */
1025
-
rc = tipc_wait_for_cond(sock, &timeout, !tsk->cong_link_cnt &&
1026
-
!tipc_group_bc_cong(grp, blks));
1020
+
rc = tipc_wait_for_cond(sock, &timeout,
1021
+
!tsk->cong_link_cnt && tsk->group &&
1022
+
!tipc_group_bc_cong(tsk->group, blks));
1027
1023
if (unlikely(rc))
1028
1024
return rc;
1025
+
1026
+
dsts = tipc_group_dests(tsk->group);
1027
+
if (!dsts->local && !dsts->remote)
1028
+
return -EHOSTUNREACH;
1029
1029
1030
1030
/* Complete message header */
1031
1031
if (dest) {
···
1040
1036
msg_set_hdr_sz(hdr, GROUP_H_SIZE);
1041
1037
msg_set_destport(hdr, 0);
1042
1038
msg_set_destnode(hdr, 0);
1043
-
msg_set_grp_bc_seqno(hdr, tipc_group_bc_snd_nxt(grp));
1039
+
msg_set_grp_bc_seqno(hdr, tipc_group_bc_snd_nxt(tsk->group));
1044
1040
1045
1041
/* Avoid getting stuck with repeated forced replicasts */
1046
1042
msg_set_grp_bc_ack_req(hdr, ack);
···
2728
2724
rhashtable_walk_start(&iter);
2729
2725
2730
2726
while ((tsk = rhashtable_walk_next(&iter)) && !IS_ERR(tsk)) {
2731
-
spin_lock_bh(&tsk->sk.sk_lock.slock);
2727
+
sock_hold(&tsk->sk);
2728
+
rhashtable_walk_stop(&iter);
2729
+
lock_sock(&tsk->sk);
2732
2730
msg = &tsk->phdr;
2733
2731
msg_set_prevnode(msg, tipc_own_addr(net));
2734
2732
msg_set_orignode(msg, tipc_own_addr(net));
2735
-
spin_unlock_bh(&tsk->sk.sk_lock.slock);
2733
+
release_sock(&tsk->sk);
2734
+
rhashtable_walk_start(&iter);
2735
+
sock_put(&tsk->sk);
2736
2736
}
2737
2737
2738
2738
rhashtable_walk_stop(&iter);
+6
-3
net/tipc/udp_media.c
+6
-3
net/tipc/udp_media.c
···
245
245
}
246
246
247
247
err = tipc_udp_xmit(net, _skb, ub, src, &rcast->addr);
248
-
if (err) {
249
-
kfree_skb(_skb);
248
+
if (err)
250
249
goto out;
251
-
}
252
250
}
253
251
err = 0;
254
252
out:
···
678
680
err = tipc_parse_udp_addr(opts[TIPC_NLA_UDP_REMOTE], &remote, NULL);
679
681
if (err)
680
682
goto err;
683
+
684
+
if (remote.proto != local.proto) {
685
+
err = -EINVAL;
686
+
goto err;
687
+
}
681
688
682
689
/* Checking remote ip address */
683
690
rmcast = tipc_udp_is_mcast_addr(&remote);
+27
-17
net/tls/tls_main.c
+27
-17
net/tls/tls_main.c
···
56
56
static struct proto *saved_tcpv6_prot;
57
57
static DEFINE_MUTEX(tcpv6_prot_mutex);
58
58
static LIST_HEAD(device_list);
59
-
static DEFINE_MUTEX(device_mutex);
59
+
static DEFINE_SPINLOCK(device_spinlock);
60
60
static struct proto tls_prots[TLS_NUM_PROTS][TLS_NUM_CONFIG][TLS_NUM_CONFIG];
61
61
static struct proto_ops tls_sw_proto_ops;
62
62
···
538
538
struct inet_connection_sock *icsk = inet_csk(sk);
539
539
struct tls_context *ctx;
540
540
541
-
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
541
+
ctx = kzalloc(sizeof(*ctx), GFP_ATOMIC);
542
542
if (!ctx)
543
543
return NULL;
544
544
545
545
icsk->icsk_ulp_data = ctx;
546
+
ctx->setsockopt = sk->sk_prot->setsockopt;
547
+
ctx->getsockopt = sk->sk_prot->getsockopt;
548
+
ctx->sk_proto_close = sk->sk_prot->close;
546
549
return ctx;
547
550
}
548
551
···
555
552
struct tls_device *dev;
556
553
int rc = 0;
557
554
558
-
mutex_lock(&device_mutex);
555
+
spin_lock_bh(&device_spinlock);
559
556
list_for_each_entry(dev, &device_list, dev_list) {
560
557
if (dev->feature && dev->feature(dev)) {
561
558
ctx = create_ctx(sk);
···
573
570
}
574
571
}
575
572
out:
576
-
mutex_unlock(&device_mutex);
573
+
spin_unlock_bh(&device_spinlock);
577
574
return rc;
578
575
}
579
576
···
582
579
struct tls_context *ctx = tls_get_ctx(sk);
583
580
struct tls_device *dev;
584
581
585
-
mutex_lock(&device_mutex);
582
+
spin_lock_bh(&device_spinlock);
586
583
list_for_each_entry(dev, &device_list, dev_list) {
587
-
if (dev->unhash)
584
+
if (dev->unhash) {
585
+
kref_get(&dev->kref);
586
+
spin_unlock_bh(&device_spinlock);
588
587
dev->unhash(dev, sk);
588
+
kref_put(&dev->kref, dev->release);
589
+
spin_lock_bh(&device_spinlock);
590
+
}
589
591
}
590
-
mutex_unlock(&device_mutex);
592
+
spin_unlock_bh(&device_spinlock);
591
593
ctx->unhash(sk);
592
594
}
593
595
···
603
595
int err;
604
596
605
597
err = ctx->hash(sk);
606
-
mutex_lock(&device_mutex);
598
+
spin_lock_bh(&device_spinlock);
607
599
list_for_each_entry(dev, &device_list, dev_list) {
608
-
if (dev->hash)
600
+
if (dev->hash) {
601
+
kref_get(&dev->kref);
602
+
spin_unlock_bh(&device_spinlock);
609
603
err |= dev->hash(dev, sk);
604
+
kref_put(&dev->kref, dev->release);
605
+
spin_lock_bh(&device_spinlock);
606
+
}
610
607
}
611
-
mutex_unlock(&device_mutex);
608
+
spin_unlock_bh(&device_spinlock);
612
609
613
610
if (err)
614
611
tls_hw_unhash(sk);
···
688
675
rc = -ENOMEM;
689
676
goto out;
690
677
}
691
-
ctx->setsockopt = sk->sk_prot->setsockopt;
692
-
ctx->getsockopt = sk->sk_prot->getsockopt;
693
-
ctx->sk_proto_close = sk->sk_prot->close;
694
678
695
679
/* Build IPv6 TLS whenever the address of tcpv6 _prot changes */
696
680
if (ip_ver == TLSV6 &&
···
709
699
710
700
void tls_register_device(struct tls_device *device)
711
701
{
712
-
mutex_lock(&device_mutex);
702
+
spin_lock_bh(&device_spinlock);
713
703
list_add_tail(&device->dev_list, &device_list);
714
-
mutex_unlock(&device_mutex);
704
+
spin_unlock_bh(&device_spinlock);
715
705
}
716
706
EXPORT_SYMBOL(tls_register_device);
717
707
718
708
void tls_unregister_device(struct tls_device *device)
719
709
{
720
-
mutex_lock(&device_mutex);
710
+
spin_lock_bh(&device_spinlock);
721
711
list_del(&device->dev_list);
722
-
mutex_unlock(&device_mutex);
712
+
spin_unlock_bh(&device_spinlock);
723
713
}
724
714
EXPORT_SYMBOL(tls_unregister_device);
725
715
+6
-1
net/vmw_vsock/af_vsock.c
+6
-1
net/vmw_vsock/af_vsock.c
···
107
107
#include <linux/mutex.h>
108
108
#include <linux/net.h>
109
109
#include <linux/poll.h>
110
+
#include <linux/random.h>
110
111
#include <linux/skbuff.h>
111
112
#include <linux/smp.h>
112
113
#include <linux/socket.h>
···
505
504
static int __vsock_bind_stream(struct vsock_sock *vsk,
506
505
struct sockaddr_vm *addr)
507
506
{
508
-
static u32 port = LAST_RESERVED_PORT + 1;
507
+
static u32 port = 0;
509
508
struct sockaddr_vm new_addr;
509
+
510
+
if (!port)
511
+
port = LAST_RESERVED_PORT + 1 +
512
+
prandom_u32_max(U32_MAX - LAST_RESERVED_PORT);
510
513
511
514
vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port);
512
515
+50
-17
net/vmw_vsock/vmci_transport.c
+50
-17
net/vmw_vsock/vmci_transport.c
···
264
264
}
265
265
266
266
static int
267
+
vmci_transport_alloc_send_control_pkt(struct sockaddr_vm *src,
268
+
struct sockaddr_vm *dst,
269
+
enum vmci_transport_packet_type type,
270
+
u64 size,
271
+
u64 mode,
272
+
struct vmci_transport_waiting_info *wait,
273
+
u16 proto,
274
+
struct vmci_handle handle)
275
+
{
276
+
struct vmci_transport_packet *pkt;
277
+
int err;
278
+
279
+
pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
280
+
if (!pkt)
281
+
return -ENOMEM;
282
+
283
+
err = __vmci_transport_send_control_pkt(pkt, src, dst, type, size,
284
+
mode, wait, proto, handle,
285
+
true);
286
+
kfree(pkt);
287
+
288
+
return err;
289
+
}
290
+
291
+
static int
267
292
vmci_transport_send_control_pkt(struct sock *sk,
268
293
enum vmci_transport_packet_type type,
269
294
u64 size,
···
297
272
u16 proto,
298
273
struct vmci_handle handle)
299
274
{
300
-
struct vmci_transport_packet *pkt;
301
275
struct vsock_sock *vsk;
302
-
int err;
303
276
304
277
vsk = vsock_sk(sk);
305
278
···
307
284
if (!vsock_addr_bound(&vsk->remote_addr))
308
285
return -EINVAL;
309
286
310
-
pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
311
-
if (!pkt)
312
-
return -ENOMEM;
313
-
314
-
err = __vmci_transport_send_control_pkt(pkt, &vsk->local_addr,
315
-
&vsk->remote_addr, type, size,
316
-
mode, wait, proto, handle,
317
-
true);
318
-
kfree(pkt);
319
-
320
-
return err;
287
+
return vmci_transport_alloc_send_control_pkt(&vsk->local_addr,
288
+
&vsk->remote_addr,
289
+
type, size, mode,
290
+
wait, proto, handle);
321
291
}
322
292
323
293
static int vmci_transport_send_reset_bh(struct sockaddr_vm *dst,
···
328
312
static int vmci_transport_send_reset(struct sock *sk,
329
313
struct vmci_transport_packet *pkt)
330
314
{
315
+
struct sockaddr_vm *dst_ptr;
316
+
struct sockaddr_vm dst;
317
+
struct vsock_sock *vsk;
318
+
331
319
if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST)
332
320
return 0;
333
-
return vmci_transport_send_control_pkt(sk,
334
-
VMCI_TRANSPORT_PACKET_TYPE_RST,
335
-
0, 0, NULL, VSOCK_PROTO_INVALID,
336
-
VMCI_INVALID_HANDLE);
321
+
322
+
vsk = vsock_sk(sk);
323
+
324
+
if (!vsock_addr_bound(&vsk->local_addr))
325
+
return -EINVAL;
326
+
327
+
if (vsock_addr_bound(&vsk->remote_addr)) {
328
+
dst_ptr = &vsk->remote_addr;
329
+
} else {
330
+
vsock_addr_init(&dst, pkt->dg.src.context,
331
+
pkt->src_port);
332
+
dst_ptr = &dst;
333
+
}
334
+
return vmci_transport_alloc_send_control_pkt(&vsk->local_addr, dst_ptr,
335
+
VMCI_TRANSPORT_PACKET_TYPE_RST,
336
+
0, 0, NULL, VSOCK_PROTO_INVALID,
337
+
VMCI_INVALID_HANDLE);
337
338
}
338
339
339
340
static int vmci_transport_send_negotiate(struct sock *sk, size_t size)
+3
-1
net/wireless/nl80211.c
+3
-1
net/wireless/nl80211.c
···
8930
8930
if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
8931
8931
int r = validate_pae_over_nl80211(rdev, info);
8932
8932
8933
-
if (r < 0)
8933
+
if (r < 0) {
8934
+
kzfree(connkeys);
8934
8935
return r;
8936
+
}
8935
8937
8936
8938
ibss.control_port_over_nl80211 = true;
8937
8939
}
+6
-1
net/xfrm/xfrm_input.c
+6
-1
net/xfrm/xfrm_input.c
···
346
346
347
347
skb->sp->xvec[skb->sp->len++] = x;
348
348
349
+
skb_dst_force(skb);
350
+
if (!skb_dst(skb)) {
351
+
XFRM_INC_STATS(net, LINUX_MIB_XFRMINERROR);
352
+
goto drop;
353
+
}
354
+
349
355
lock:
350
356
spin_lock(&x->lock);
351
357
···
391
385
XFRM_SKB_CB(skb)->seq.input.low = seq;
392
386
XFRM_SKB_CB(skb)->seq.input.hi = seq_hi;
393
387
394
-
skb_dst_force(skb);
395
388
dev_hold(skb->dev);
396
389
397
390
if (crypto_done)
+1
net/xfrm/xfrm_output.c
+1
net/xfrm/xfrm_output.c
+8
-2
net/xfrm/xfrm_state.c
+8
-2
net/xfrm/xfrm_state.c
···
426
426
module_put(mode->owner);
427
427
}
428
428
429
+
void xfrm_state_free(struct xfrm_state *x)
430
+
{
431
+
kmem_cache_free(xfrm_state_cache, x);
432
+
}
433
+
EXPORT_SYMBOL(xfrm_state_free);
434
+
429
435
static void xfrm_state_gc_destroy(struct xfrm_state *x)
430
436
{
431
437
tasklet_hrtimer_cancel(&x->mtimer);
···
458
452
}
459
453
xfrm_dev_state_free(x);
460
454
security_xfrm_state_free(x);
461
-
kmem_cache_free(xfrm_state_cache, x);
455
+
xfrm_state_free(x);
462
456
}
463
457
464
458
static void xfrm_state_gc_task(struct work_struct *work)
···
794
788
{
795
789
spin_lock_bh(&net->xfrm.xfrm_state_lock);
796
790
si->sadcnt = net->xfrm.state_num;
797
-
si->sadhcnt = net->xfrm.state_hmask;
791
+
si->sadhcnt = net->xfrm.state_hmask + 1;
798
792
si->sadhmcnt = xfrm_state_hashmax;
799
793
spin_unlock_bh(&net->xfrm.xfrm_state_lock);
800
794
}
+2
-2
net/xfrm/xfrm_user.c
+2
-2
net/xfrm/xfrm_user.c
+1
-1
tools/include/uapi/linux/netlink.h
+1
-1
tools/include/uapi/linux/netlink.h
+17
-19
tools/testing/selftests/bpf/bpf_flow.c
+17
-19
tools/testing/selftests/bpf/bpf_flow.c
···
70
70
{
71
71
void *data_end = (void *)(long)skb->data_end;
72
72
void *data = (void *)(long)skb->data;
73
-
__u16 nhoff = skb->flow_keys->nhoff;
73
+
__u16 thoff = skb->flow_keys->thoff;
74
74
__u8 *hdr;
75
75
76
76
/* Verifies this variable offset does not overflow */
77
-
if (nhoff > (USHRT_MAX - hdr_size))
77
+
if (thoff > (USHRT_MAX - hdr_size))
78
78
return NULL;
79
79
80
-
hdr = data + nhoff;
80
+
hdr = data + thoff;
81
81
if (hdr + hdr_size <= data_end)
82
82
return hdr;
83
83
84
-
if (bpf_skb_load_bytes(skb, nhoff, buffer, hdr_size))
84
+
if (bpf_skb_load_bytes(skb, thoff, buffer, hdr_size))
85
85
return NULL;
86
86
87
87
return buffer;
···
158
158
/* Only inspect standard GRE packets with version 0 */
159
159
return BPF_OK;
160
160
161
-
keys->nhoff += sizeof(*gre); /* Step over GRE Flags and Proto */
161
+
keys->thoff += sizeof(*gre); /* Step over GRE Flags and Proto */
162
162
if (GRE_IS_CSUM(gre->flags))
163
-
keys->nhoff += 4; /* Step over chksum and Padding */
163
+
keys->thoff += 4; /* Step over chksum and Padding */
164
164
if (GRE_IS_KEY(gre->flags))
165
-
keys->nhoff += 4; /* Step over key */
165
+
keys->thoff += 4; /* Step over key */
166
166
if (GRE_IS_SEQ(gre->flags))
167
-
keys->nhoff += 4; /* Step over sequence number */
167
+
keys->thoff += 4; /* Step over sequence number */
168
168
169
169
keys->is_encap = true;
170
170
···
174
174
if (!eth)
175
175
return BPF_DROP;
176
176
177
-
keys->nhoff += sizeof(*eth);
177
+
keys->thoff += sizeof(*eth);
178
178
179
179
return parse_eth_proto(skb, eth->h_proto);
180
180
} else {
···
191
191
if ((__u8 *)tcp + (tcp->doff << 2) > data_end)
192
192
return BPF_DROP;
193
193
194
-
keys->thoff = keys->nhoff;
195
194
keys->sport = tcp->source;
196
195
keys->dport = tcp->dest;
197
196
return BPF_OK;
···
200
201
if (!udp)
201
202
return BPF_DROP;
202
203
203
-
keys->thoff = keys->nhoff;
204
204
keys->sport = udp->source;
205
205
keys->dport = udp->dest;
206
206
return BPF_OK;
···
250
252
keys->ipv4_src = iph->saddr;
251
253
keys->ipv4_dst = iph->daddr;
252
254
253
-
keys->nhoff += iph->ihl << 2;
254
-
if (data + keys->nhoff > data_end)
255
+
keys->thoff += iph->ihl << 2;
256
+
if (data + keys->thoff > data_end)
255
257
return BPF_DROP;
256
258
257
259
if (iph->frag_off & bpf_htons(IP_MF | IP_OFFSET)) {
···
283
285
keys->addr_proto = ETH_P_IPV6;
284
286
memcpy(&keys->ipv6_src, &ip6h->saddr, 2*sizeof(ip6h->saddr));
285
287
286
-
keys->nhoff += sizeof(struct ipv6hdr);
288
+
keys->thoff += sizeof(struct ipv6hdr);
287
289
288
290
return parse_ipv6_proto(skb, ip6h->nexthdr);
289
291
}
···
299
301
/* hlen is in 8-octets and does not include the first 8 bytes
300
302
* of the header
301
303
*/
302
-
skb->flow_keys->nhoff += (1 + ip6h->hdrlen) << 3;
304
+
skb->flow_keys->thoff += (1 + ip6h->hdrlen) << 3;
303
305
304
306
return parse_ipv6_proto(skb, ip6h->nexthdr);
305
307
}
···
313
315
if (!fragh)
314
316
return BPF_DROP;
315
317
316
-
keys->nhoff += sizeof(*fragh);
318
+
keys->thoff += sizeof(*fragh);
317
319
keys->is_frag = true;
318
320
if (!(fragh->frag_off & bpf_htons(IP6_OFFSET)))
319
321
keys->is_first_frag = true;
···
339
341
__be16 proto;
340
342
341
343
/* Peek back to see if single or double-tagging */
342
-
if (bpf_skb_load_bytes(skb, keys->nhoff - sizeof(proto), &proto,
344
+
if (bpf_skb_load_bytes(skb, keys->thoff - sizeof(proto), &proto,
343
345
sizeof(proto)))
344
346
return BPF_DROP;
345
347
···
352
354
if (vlan->h_vlan_encapsulated_proto != bpf_htons(ETH_P_8021Q))
353
355
return BPF_DROP;
354
356
355
-
keys->nhoff += sizeof(*vlan);
357
+
keys->thoff += sizeof(*vlan);
356
358
}
357
359
358
360
vlan = bpf_flow_dissect_get_header(skb, sizeof(*vlan), &_vlan);
359
361
if (!vlan)
360
362
return BPF_DROP;
361
363
362
-
keys->nhoff += sizeof(*vlan);
364
+
keys->thoff += sizeof(*vlan);
363
365
/* Only allow 8021AD + 8021Q double tagging and no triple tagging.*/
364
366
if (vlan->h_vlan_encapsulated_proto == bpf_htons(ETH_P_8021AD) ||
365
367
vlan->h_vlan_encapsulated_proto == bpf_htons(ETH_P_8021Q))
+33
-5
tools/testing/selftests/bpf/test_verifier.c
+33
-5
tools/testing/selftests/bpf/test_verifier.c
···
13915
13915
.result_unpriv = REJECT,
13916
13916
.result = ACCEPT,
13917
13917
},
13918
+
{
13919
+
"calls: cross frame pruning",
13920
+
.insns = {
13921
+
/* r8 = !!random();
13922
+
* call pruner()
13923
+
* if (r8)
13924
+
* do something bad;
13925
+
*/
13926
+
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
13927
+
BPF_FUNC_get_prandom_u32),
13928
+
BPF_MOV64_IMM(BPF_REG_8, 0),
13929
+
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
13930
+
BPF_MOV64_IMM(BPF_REG_8, 1),
13931
+
BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
13932
+
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4),
13933
+
BPF_JMP_IMM(BPF_JEQ, BPF_REG_8, 1, 1),
13934
+
BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_1, 0),
13935
+
BPF_MOV64_IMM(BPF_REG_0, 0),
13936
+
BPF_EXIT_INSN(),
13937
+
BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 0),
13938
+
BPF_EXIT_INSN(),
13939
+
},
13940
+
.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
13941
+
.errstr_unpriv = "function calls to other bpf functions are allowed for root only",
13942
+
.result_unpriv = REJECT,
13943
+
.errstr = "!read_ok",
13944
+
.result = REJECT,
13945
+
},
13918
13946
};
13919
13947
13920
13948
static int probe_filter_length(const struct bpf_insn *fp)
···
13968
13940
return fd;
13969
13941
}
13970
13942
13971
-
static int create_prog_dummy1(enum bpf_map_type prog_type)
13943
+
static int create_prog_dummy1(enum bpf_prog_type prog_type)
13972
13944
{
13973
13945
struct bpf_insn prog[] = {
13974
13946
BPF_MOV64_IMM(BPF_REG_0, 42),
···
13979
13951
ARRAY_SIZE(prog), "GPL", 0, NULL, 0);
13980
13952
}
13981
13953
13982
-
static int create_prog_dummy2(enum bpf_map_type prog_type, int mfd, int idx)
13954
+
static int create_prog_dummy2(enum bpf_prog_type prog_type, int mfd, int idx)
13983
13955
{
13984
13956
struct bpf_insn prog[] = {
13985
13957
BPF_MOV64_IMM(BPF_REG_3, idx),
···
13994
13966
ARRAY_SIZE(prog), "GPL", 0, NULL, 0);
13995
13967
}
13996
13968
13997
-
static int create_prog_array(enum bpf_map_type prog_type, uint32_t max_elem,
13969
+
static int create_prog_array(enum bpf_prog_type prog_type, uint32_t max_elem,
13998
13970
int p1key)
13999
13971
{
14000
13972
int p2key = 1;
···
14065
14037
14066
14038
static char bpf_vlog[UINT_MAX >> 8];
14067
14039
14068
-
static void do_test_fixup(struct bpf_test *test, enum bpf_map_type prog_type,
14040
+
static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type,
14069
14041
struct bpf_insn *prog, int *map_fds)
14070
14042
{
14071
14043
int *fixup_map_hash_8b = test->fixup_map_hash_8b;
···
14194
14166
do {
14195
14167
prog[*fixup_map_stacktrace].imm = map_fds[12];
14196
14168
fixup_map_stacktrace++;
14197
-
} while (fixup_map_stacktrace);
14169
+
} while (*fixup_map_stacktrace);
14198
14170
}
14199
14171
}
14200
14172
+1
tools/testing/selftests/net/Makefile
+1
tools/testing/selftests/net/Makefile
···
7
7
TEST_PROGS := run_netsocktests run_afpackettests test_bpf.sh netdevice.sh rtnetlink.sh
8
8
TEST_PROGS += fib_tests.sh fib-onlink-tests.sh pmtu.sh udpgso.sh ip_defrag.sh
9
9
TEST_PROGS += udpgso_bench.sh fib_rule_tests.sh msg_zerocopy.sh psock_snd.sh
10
+
TEST_PROGS += test_vxlan_fdb_changelink.sh
10
11
TEST_PROGS_EXTENDED := in_netns.sh
11
12
TEST_GEN_FILES = socket
12
13
TEST_GEN_FILES += psock_fanout psock_tpacket msg_zerocopy
+29
tools/testing/selftests/net/test_vxlan_fdb_changelink.sh
+29
tools/testing/selftests/net/test_vxlan_fdb_changelink.sh
···
1
+
#!/bin/bash
2
+
# SPDX-License-Identifier: GPL-2.0
3
+
4
+
# Check FDB default-remote handling across "ip link set".
5
+
6
+
check_remotes()
7
+
{
8
+
local what=$1; shift
9
+
local N=$(bridge fdb sh dev vx | grep 00:00:00:00:00:00 | wc -l)
10
+
11
+
echo -ne "expected two remotes after $what\t"
12
+
if [[ $N != 2 ]]; then
13
+
echo "[FAIL]"
14
+
EXIT_STATUS=1
15
+
else
16
+
echo "[ OK ]"
17
+
fi
18
+
}
19
+
20
+
ip link add name vx up type vxlan id 2000 dstport 4789
21
+
bridge fdb ap dev vx 00:00:00:00:00:00 dst 192.0.2.20 self permanent
22
+
bridge fdb ap dev vx 00:00:00:00:00:00 dst 192.0.2.30 self permanent
23
+
check_remotes "fdb append"
24
+
25
+
ip link set dev vx type vxlan remote 192.0.2.30
26
+
check_remotes "link set"
27
+
28
+
ip link del dev vx
29
+
exit $EXIT_STATUS