forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-10-22 8ac6c7a54ed1b98d142dce24b11c6de6a1e239a5 
 kernel/net/xfrm/xfrm_input.c
....@@ -21,6 +21,8 @@
2121 #include <net/ip_tunnels.h>
2222 #include <net/ip6_tunnel.h>
2323 
24
+#include "xfrm_inout.h"
25
+
2426 struct xfrm_trans_tasklet {
2527 	struct tasklet_struct tasklet;
2628 	struct sk_buff_head queue;
....@@ -34,14 +36,13 @@
3436 #endif
3537 	} header;
3638 	int (*finish)(struct net *net, struct sock *sk, struct sk_buff *skb);
39
+	struct net *net;
3740 };
3841 
3942 #define XFRM_TRANS_SKB_CB(__skb) ((struct xfrm_trans_cb *)&((__skb)->cb[0]))
4043 
41
-static struct kmem_cache *secpath_cachep __ro_after_init;
42
-
4344 static DEFINE_SPINLOCK(xfrm_input_afinfo_lock);
44
-static struct xfrm_input_afinfo const __rcu *xfrm_input_afinfo[AF_INET6 + 1];
45
+static struct xfrm_input_afinfo const __rcu *xfrm_input_afinfo[2][AF_INET6 + 1];
4546 
4647 static struct gro_cells gro_cells;
4748 static struct net_device xfrm_napi_dev;
....@@ -52,14 +53,14 @@
5253 {
5354 	int err = 0;
5455 
55
-	if (WARN_ON(afinfo->family >= ARRAY_SIZE(xfrm_input_afinfo)))
56
+	if (WARN_ON(afinfo->family > AF_INET6))
5657 		return -EAFNOSUPPORT;
5758 
5859 	spin_lock_bh(&xfrm_input_afinfo_lock);
59
-	if (unlikely(xfrm_input_afinfo[afinfo->family] != NULL))
60
+	if (unlikely(xfrm_input_afinfo[afinfo->is_ipip][afinfo->family]))
6061 		err = -EEXIST;
6162 	else
62
-		rcu_assign_pointer(xfrm_input_afinfo[afinfo->family], afinfo);
63
+		rcu_assign_pointer(xfrm_input_afinfo[afinfo->is_ipip][afinfo->family], afinfo);
6364 	spin_unlock_bh(&xfrm_input_afinfo_lock);
6465 	return err;
6566 }
....@@ -70,11 +71,11 @@
7071 	int err = 0;
7172 
7273 	spin_lock_bh(&xfrm_input_afinfo_lock);
73
-	if (likely(xfrm_input_afinfo[afinfo->family] != NULL)) {
74
-		if (unlikely(xfrm_input_afinfo[afinfo->family] != afinfo))
74
+	if (likely(xfrm_input_afinfo[afinfo->is_ipip][afinfo->family])) {
75
+		if (unlikely(xfrm_input_afinfo[afinfo->is_ipip][afinfo->family] != afinfo))
7576 			err = -EINVAL;
7677 		else
77
-			RCU_INIT_POINTER(xfrm_input_afinfo[afinfo->family], NULL);
78
+			RCU_INIT_POINTER(xfrm_input_afinfo[afinfo->is_ipip][afinfo->family], NULL);
7879 	}
7980 	spin_unlock_bh(&xfrm_input_afinfo_lock);
8081 	synchronize_rcu();
....@@ -82,15 +83,15 @@
8283 }
8384 EXPORT_SYMBOL(xfrm_input_unregister_afinfo);
8485 
85
-static const struct xfrm_input_afinfo *xfrm_input_get_afinfo(unsigned int family)
86
+static const struct xfrm_input_afinfo *xfrm_input_get_afinfo(u8 family, bool is_ipip)
8687 {
8788 	const struct xfrm_input_afinfo *afinfo;
8889 
89
-	if (WARN_ON_ONCE(family >= ARRAY_SIZE(xfrm_input_afinfo)))
90
+	if (WARN_ON_ONCE(family > AF_INET6))
9091 		return NULL;
9192 
9293 	rcu_read_lock();
93
-	afinfo = rcu_dereference(xfrm_input_afinfo[family]);
94
+	afinfo = rcu_dereference(xfrm_input_afinfo[is_ipip][family]);
9495 	if (unlikely(!afinfo))
9596 		rcu_read_unlock();
9697 	return afinfo;
....@@ -99,9 +100,11 @@
99100 static int xfrm_rcv_cb(struct sk_buff *skb, unsigned int family, u8 protocol,
100101 		       int err)
101102 {
103
+	bool is_ipip = (protocol == IPPROTO_IPIP || protocol == IPPROTO_IPV6);
104
+	const struct xfrm_input_afinfo *afinfo;
102105 	int ret;
103
-	const struct xfrm_input_afinfo *afinfo = xfrm_input_get_afinfo(family);
104106 
107
+	afinfo = xfrm_input_get_afinfo(family, is_ipip);
105108 	if (!afinfo)
106109 		return -EAFNOSUPPORT;
107110 
....@@ -111,55 +114,24 @@
111114 	return ret;
112115 }
113116 
114
-void __secpath_destroy(struct sec_path *sp)
117
+struct sec_path *secpath_set(struct sk_buff *skb)
115118 {
116
-	int i;
117
-	for (i = 0; i < sp->len; i++)
118
-		xfrm_state_put(sp->xvec[i]);
119
-	kmem_cache_free(secpath_cachep, sp);
120
-}
121
-EXPORT_SYMBOL(__secpath_destroy);
119
+	struct sec_path *sp, *tmp = skb_ext_find(skb, SKB_EXT_SEC_PATH);
122120 
123
-struct sec_path *secpath_dup(struct sec_path *src)
124
-{
125
-	struct sec_path *sp;
126
-
127
-	sp = kmem_cache_alloc(secpath_cachep, GFP_ATOMIC);
121
+	sp = skb_ext_add(skb, SKB_EXT_SEC_PATH);
128122 	if (!sp)
129123 		return NULL;
130124 
131
-	sp->len = 0;
132
-	sp->olen = 0;
125
+	if (tmp) /* reused existing one (was COW'd if needed) */
126
+		return sp;
133127 
128
+	/* allocated new secpath */
134129 	memset(sp->ovec, 0, sizeof(sp->ovec));
130
+	sp->olen = 0;
131
+	sp->len = 0;
132
+	sp->verified_cnt = 0;
135133 
136
-	if (src) {
137
-		int i;
138
-
139
-		memcpy(sp, src, sizeof(*sp));
140
-		for (i = 0; i < sp->len; i++)
141
-			xfrm_state_hold(sp->xvec[i]);
142
-	}
143
-	refcount_set(&sp->refcnt, 1);
144134 	return sp;
145
-}
146
-EXPORT_SYMBOL(secpath_dup);
147
-
148
-int secpath_set(struct sk_buff *skb)
149
-{
150
-	struct sec_path *sp;
151
-
152
-	/* Allocate new secpath or COW existing one. */
153
-	if (!skb->sp || refcount_read(&skb->sp->refcnt) != 1) {
154
-		sp = secpath_dup(skb->sp);
155
-		if (!sp)
156
-			return -ENOMEM;
157
-
158
-		if (skb->sp)
159
-			secpath_put(skb->sp);
160
-		skb->sp = sp;
161
-	}
162
-	return 0;
163135 }
164136 EXPORT_SYMBOL(secpath_set);
165137 
....@@ -200,35 +172,300 @@
200172 }
201173 EXPORT_SYMBOL(xfrm_parse_spi);
202174 
203
-int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb)
175
+static int xfrm4_remove_beet_encap(struct xfrm_state *x, struct sk_buff *skb)
204176 {
205
-	struct xfrm_mode *inner_mode = x->inner_mode;
177
+	struct iphdr *iph;
178
+	int optlen = 0;
179
+	int err = -EINVAL;
180
+
181
+	if (unlikely(XFRM_MODE_SKB_CB(skb)->protocol == IPPROTO_BEETPH)) {
182
+		struct ip_beet_phdr *ph;
183
+		int phlen;
184
+
185
+		if (!pskb_may_pull(skb, sizeof(*ph)))
186
+			goto out;
187
+
188
+		ph = (struct ip_beet_phdr *)skb->data;
189
+
190
+		phlen = sizeof(*ph) + ph->padlen;
191
+		optlen = ph->hdrlen * 8 + (IPV4_BEET_PHMAXLEN - phlen);
192
+		if (optlen < 0 || optlen & 3 || optlen > 250)
193
+			goto out;
194
+
195
+		XFRM_MODE_SKB_CB(skb)->protocol = ph->nexthdr;
196
+
197
+		if (!pskb_may_pull(skb, phlen))
198
+			goto out;
199
+		__skb_pull(skb, phlen);
200
+	}
201
+
202
+	skb_push(skb, sizeof(*iph));
203
+	skb_reset_network_header(skb);
204
+	skb_mac_header_rebuild(skb);
205
+
206
+	xfrm4_beet_make_header(skb);
207
+
208
+	iph = ip_hdr(skb);
209
+
210
+	iph->ihl += optlen / 4;
211
+	iph->tot_len = htons(skb->len);
212
+	iph->daddr = x->sel.daddr.a4;
213
+	iph->saddr = x->sel.saddr.a4;
214
+	iph->check = 0;
215
+	iph->check = ip_fast_csum(skb_network_header(skb), iph->ihl);
216
+	err = 0;
217
+out:
218
+	return err;
219
+}
220
+
221
+static void ipip_ecn_decapsulate(struct sk_buff *skb)
222
+{
223
+	struct iphdr *inner_iph = ipip_hdr(skb);
224
+
225
+	if (INET_ECN_is_ce(XFRM_MODE_SKB_CB(skb)->tos))
226
+		IP_ECN_set_ce(inner_iph);
227
+}
228
+
229
+static int xfrm4_remove_tunnel_encap(struct xfrm_state *x, struct sk_buff *skb)
230
+{
231
+	int err = -EINVAL;
232
+
233
+	if (XFRM_MODE_SKB_CB(skb)->protocol != IPPROTO_IPIP)
234
+		goto out;
235
+
236
+	if (!pskb_may_pull(skb, sizeof(struct iphdr)))
237
+		goto out;
238
+
239
+	err = skb_unclone(skb, GFP_ATOMIC);
240
+	if (err)
241
+		goto out;
242
+
243
+	if (x->props.flags & XFRM_STATE_DECAP_DSCP)
244
+		ipv4_copy_dscp(XFRM_MODE_SKB_CB(skb)->tos, ipip_hdr(skb));
245
+	if (!(x->props.flags & XFRM_STATE_NOECN))
246
+		ipip_ecn_decapsulate(skb);
247
+
248
+	skb_reset_network_header(skb);
249
+	skb_mac_header_rebuild(skb);
250
+	if (skb->mac_len)
251
+		eth_hdr(skb)->h_proto = skb->protocol;
252
+
253
+	err = 0;
254
+
255
+out:
256
+	return err;
257
+}
258
+
259
+static void ipip6_ecn_decapsulate(struct sk_buff *skb)
260
+{
261
+	struct ipv6hdr *inner_iph = ipipv6_hdr(skb);
262
+
263
+	if (INET_ECN_is_ce(XFRM_MODE_SKB_CB(skb)->tos))
264
+		IP6_ECN_set_ce(skb, inner_iph);
265
+}
266
+
267
+static int xfrm6_remove_tunnel_encap(struct xfrm_state *x, struct sk_buff *skb)
268
+{
269
+	int err = -EINVAL;
270
+
271
+	if (XFRM_MODE_SKB_CB(skb)->protocol != IPPROTO_IPV6)
272
+		goto out;
273
+	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
274
+		goto out;
275
+
276
+	err = skb_unclone(skb, GFP_ATOMIC);
277
+	if (err)
278
+		goto out;
279
+
280
+	if (x->props.flags & XFRM_STATE_DECAP_DSCP)
281
+		ipv6_copy_dscp(XFRM_MODE_SKB_CB(skb)->tos, ipipv6_hdr(skb));
282
+	if (!(x->props.flags & XFRM_STATE_NOECN))
283
+		ipip6_ecn_decapsulate(skb);
284
+
285
+	skb_reset_network_header(skb);
286
+	skb_mac_header_rebuild(skb);
287
+	if (skb->mac_len)
288
+		eth_hdr(skb)->h_proto = skb->protocol;
289
+
290
+	err = 0;
291
+
292
+out:
293
+	return err;
294
+}
295
+
296
+static int xfrm6_remove_beet_encap(struct xfrm_state *x, struct sk_buff *skb)
297
+{
298
+	struct ipv6hdr *ip6h;
299
+	int size = sizeof(struct ipv6hdr);
206300 	int err;
207301 
208
-	err = x->outer_mode->afinfo->extract_input(x, skb);
302
+	err = skb_cow_head(skb, size + skb->mac_len);
209303 	if (err)
210
-		return err;
304
+		goto out;
305
+
306
+	__skb_push(skb, size);
307
+	skb_reset_network_header(skb);
308
+	skb_mac_header_rebuild(skb);
309
+
310
+	xfrm6_beet_make_header(skb);
311
+
312
+	ip6h = ipv6_hdr(skb);
313
+	ip6h->payload_len = htons(skb->len - size);
314
+	ip6h->daddr = x->sel.daddr.in6;
315
+	ip6h->saddr = x->sel.saddr.in6;
316
+	err = 0;
317
+out:
318
+	return err;
319
+}
320
+
321
+/* Remove encapsulation header.
322
+ *
323
+ * The IP header will be moved over the top of the encapsulation
324
+ * header.
325
+ *
326
+ * On entry, the transport header shall point to where the IP header
327
+ * should be and the network header shall be set to where the IP
328
+ * header currently is.  skb->data shall point to the start of the
329
+ * payload.
330
+ */
331
+static int
332
+xfrm_inner_mode_encap_remove(struct xfrm_state *x,
333
+			     const struct xfrm_mode *inner_mode,
334
+			     struct sk_buff *skb)
335
+{
336
+	switch (inner_mode->encap) {
337
+	case XFRM_MODE_BEET:
338
+		if (inner_mode->family == AF_INET)
339
+			return xfrm4_remove_beet_encap(x, skb);
340
+		if (inner_mode->family == AF_INET6)
341
+			return xfrm6_remove_beet_encap(x, skb);
342
+		break;
343
+	case XFRM_MODE_TUNNEL:
344
+		if (inner_mode->family == AF_INET)
345
+			return xfrm4_remove_tunnel_encap(x, skb);
346
+		if (inner_mode->family == AF_INET6)
347
+			return xfrm6_remove_tunnel_encap(x, skb);
348
+		break;
349
+	}
350
+
351
+	WARN_ON_ONCE(1);
352
+	return -EOPNOTSUPP;
353
+}
354
+
355
+static int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb)
356
+{
357
+	const struct xfrm_mode *inner_mode = &x->inner_mode;
358
+
359
+	switch (x->outer_mode.family) {
360
+	case AF_INET:
361
+		xfrm4_extract_header(skb);
362
+		break;
363
+	case AF_INET6:
364
+		xfrm6_extract_header(skb);
365
+		break;
366
+	default:
367
+		WARN_ON_ONCE(1);
368
+		return -EAFNOSUPPORT;
369
+	}
211370 
212371 	if (x->sel.family == AF_UNSPEC) {
213372 		inner_mode = xfrm_ip2inner_mode(x, XFRM_MODE_SKB_CB(skb)->protocol);
214
-		if (inner_mode == NULL)
373
+		if (!inner_mode)
215374 			return -EAFNOSUPPORT;
216375 	}
217376 
218
-	skb->protocol = inner_mode->afinfo->eth_proto;
219
-	return inner_mode->input2(x, skb);
377
+	switch (inner_mode->family) {
378
+	case AF_INET:
379
+		skb->protocol = htons(ETH_P_IP);
380
+		break;
381
+	case AF_INET6:
382
+		skb->protocol = htons(ETH_P_IPV6);
383
+		break;
384
+	default:
385
+		WARN_ON_ONCE(1);
386
+		break;
387
+	}
388
+
389
+	return xfrm_inner_mode_encap_remove(x, inner_mode, skb);
220390 }
221
-EXPORT_SYMBOL(xfrm_prepare_input);
391
+
392
+/* Remove encapsulation header.
393
+ *
394
+ * The IP header will be moved over the top of the encapsulation header.
395
+ *
396
+ * On entry, skb_transport_header() shall point to where the IP header
397
+ * should be and skb_network_header() shall be set to where the IP header
398
+ * currently is.  skb->data shall point to the start of the payload.
399
+ */
400
+static int xfrm4_transport_input(struct xfrm_state *x, struct sk_buff *skb)
401
+{
402
+	int ihl = skb->data - skb_transport_header(skb);
403
+
404
+	if (skb->transport_header != skb->network_header) {
405
+		memmove(skb_transport_header(skb),
406
+			skb_network_header(skb), ihl);
407
+		skb->network_header = skb->transport_header;
408
+	}
409
+	ip_hdr(skb)->tot_len = htons(skb->len + ihl);
410
+	skb_reset_transport_header(skb);
411
+	return 0;
412
+}
413
+
414
+static int xfrm6_transport_input(struct xfrm_state *x, struct sk_buff *skb)
415
+{
416
+#if IS_ENABLED(CONFIG_IPV6)
417
+	int ihl = skb->data - skb_transport_header(skb);
418
+
419
+	if (skb->transport_header != skb->network_header) {
420
+		memmove(skb_transport_header(skb),
421
+			skb_network_header(skb), ihl);
422
+		skb->network_header = skb->transport_header;
423
+	}
424
+	ipv6_hdr(skb)->payload_len = htons(skb->len + ihl -
425
+					   sizeof(struct ipv6hdr));
426
+	skb_reset_transport_header(skb);
427
+	return 0;
428
+#else
429
+	WARN_ON_ONCE(1);
430
+	return -EAFNOSUPPORT;
431
+#endif
432
+}
433
+
434
+static int xfrm_inner_mode_input(struct xfrm_state *x,
435
+				 const struct xfrm_mode *inner_mode,
436
+				 struct sk_buff *skb)
437
+{
438
+	switch (inner_mode->encap) {
439
+	case XFRM_MODE_BEET:
440
+	case XFRM_MODE_TUNNEL:
441
+		return xfrm_prepare_input(x, skb);
442
+	case XFRM_MODE_TRANSPORT:
443
+		if (inner_mode->family == AF_INET)
444
+			return xfrm4_transport_input(x, skb);
445
+		if (inner_mode->family == AF_INET6)
446
+			return xfrm6_transport_input(x, skb);
447
+		break;
448
+	case XFRM_MODE_ROUTEOPTIMIZATION:
449
+		WARN_ON_ONCE(1);
450
+		break;
451
+	default:
452
+		WARN_ON_ONCE(1);
453
+		break;
454
+	}
455
+
456
+	return -EOPNOTSUPP;
457
+}
222458 
223459 int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
224460 {
461
+	const struct xfrm_state_afinfo *afinfo;
225462 	struct net *net = dev_net(skb->dev);
463
+	const struct xfrm_mode *inner_mode;
226464 	int err;
227465 	__be32 seq;
228466 	__be32 seq_hi;
229467 	struct xfrm_state *x = NULL;
230468 	xfrm_address_t *daddr;
231
-	struct xfrm_mode *inner_mode;
232469 	u32 mark = skb->mark;
233470 	unsigned int family = AF_UNSPEC;
234471 	int decaps = 0;
....@@ -236,6 +473,7 @@
236473 	bool xfrm_gro = false;
237474 	bool crypto_done = false;
238475 	struct xfrm_offload *xo = xfrm_offload(skb);
476
+	struct sec_path *sp;
239477 
240478 	if (encap_type < 0) {
241479 		x = xfrm_input_state(skb);
....@@ -252,7 +490,7 @@
252490 			goto drop;
253491 		}
254492 
255
-		family = x->outer_mode->afinfo->family;
493
+		family = x->outer_mode.family;
256494 
257495 		/* An encap_type of -1 indicates async resumption. */
258496 		if (encap_type == -1) {
....@@ -315,8 +553,8 @@
315553 		break;
316554 	}
317555 
318
-	err = secpath_set(skb);
319
-	if (err) {
556
+	sp = secpath_set(skb);
557
+	if (!sp) {
320558 		XFRM_INC_STATS(net, LINUX_MIB_XFRMINERROR);
321559 		goto drop;
322560 	}
....@@ -331,7 +569,9 @@
331569 	daddr = (xfrm_address_t *)(skb_network_header(skb) +
332570 				   XFRM_SPI_SKB_CB(skb)->daddroff);
333571 	do {
334
-		if (skb->sp->len == XFRM_MAX_DEPTH) {
572
+		sp = skb_sec_path(skb);
573
+
574
+		if (sp->len == XFRM_MAX_DEPTH) {
335575 			secpath_reset(skb);
336576 			XFRM_INC_STATS(net, LINUX_MIB_XFRMINBUFFERERROR);
337577 			goto drop;
....@@ -347,7 +587,7 @@
347587 
348588 		skb->mark = xfrm_smark_get(skb->mark, x);
349589 
350
-		skb->sp->xvec[skb->sp->len++] = x;
590
+		sp->xvec[sp->len++] = x;
351591 
352592 		skb_dst_force(skb);
353593 		if (!skb_dst(skb)) {
....@@ -434,7 +674,7 @@
434674 
435675 		XFRM_MODE_SKB_CB(skb)->protocol = nexthdr;
436676 
437
-		inner_mode = x->inner_mode;
677
+		inner_mode = &x->inner_mode;
438678 
439679 		if (x->sel.family == AF_UNSPEC) {
440680 			inner_mode = xfrm_ip2inner_mode(x, XFRM_MODE_SKB_CB(skb)->protocol);
....@@ -444,12 +684,12 @@
444684 			}
445685 		}
446686 
447
-		if (inner_mode->input(x, skb)) {
687
+		if (xfrm_inner_mode_input(x, inner_mode, skb)) {
448688 			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
449689 			goto drop;
450690 		}
451691 
452
-		if (x->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL) {
692
+		if (x->outer_mode.flags & XFRM_MODE_FLAG_TUNNEL) {
453693 			decaps = 1;
454694 			break;
455695 		}
....@@ -459,7 +699,7 @@
459699 		 * transport mode so the outer address is identical.
460700 		 */
461701 		daddr = &x->id.daddr;
462
-		family = x->outer_mode->afinfo->family;
702
+		family = x->outer_mode.family;
463703 
464704 		err = xfrm_parse_spi(skb, nexthdr, &spi, &seq);
465705 		if (err < 0) {
....@@ -473,11 +713,12 @@
473713 	if (err)
474714 		goto drop;
475715 
476
-	nf_reset(skb);
716
+	nf_reset_ct(skb);
477717 
478718 	if (decaps) {
479
-		if (skb->sp)
480
-			skb->sp->olen = 0;
719
+		sp = skb_sec_path(skb);
720
+		if (sp)
721
+			sp->olen = 0;
481722 		skb_dst_drop(skb);
482723 		gro_cells_receive(&gro_cells, skb);
483724 		return 0;
....@@ -486,10 +727,16 @@
486727 		if (xo)
487728 			xfrm_gro = xo->flags & XFRM_GRO;
488729 
489
-		err = x->inner_mode->afinfo->transport_finish(skb, xfrm_gro || async);
730
+		err = -EAFNOSUPPORT;
731
+		rcu_read_lock();
732
+		afinfo = xfrm_state_afinfo_get_rcu(x->inner_mode.family);
733
+		if (likely(afinfo))
734
+			err = afinfo->transport_finish(skb, xfrm_gro || async);
735
+		rcu_read_unlock();
490736 		if (xfrm_gro) {
491
-			if (skb->sp)
492
-				skb->sp->olen = 0;
737
+			sp = skb_sec_path(skb);
738
+			if (sp)
739
+				sp->olen = 0;
493740 			skb_dst_drop(skb);
494741 			gro_cells_receive(&gro_cells, skb);
495742 			return err;
....@@ -523,24 +770,36 @@
523770 	skb_queue_splice_init(&trans->queue, &queue);
524771 
525772 	while ((skb = __skb_dequeue(&queue)))
526
-		XFRM_TRANS_SKB_CB(skb)->finish(dev_net(skb->dev), NULL, skb);
773
+		XFRM_TRANS_SKB_CB(skb)->finish(XFRM_TRANS_SKB_CB(skb)->net,
774
+					       NULL, skb);
527775 }
528776 
529
-int xfrm_trans_queue(struct sk_buff *skb,
530
-		     int (*finish)(struct net *, struct sock *,
531
-				   struct sk_buff *))
777
+int xfrm_trans_queue_net(struct net *net, struct sk_buff *skb,
778
+			 int (*finish)(struct net *, struct sock *,
779
+				       struct sk_buff *))
532780 {
533781 	struct xfrm_trans_tasklet *trans;
534782 
535783 	trans = this_cpu_ptr(&xfrm_trans_tasklet);
536784 
537
-	if (skb_queue_len(&trans->queue) >= netdev_max_backlog)
785
+	if (skb_queue_len(&trans->queue) >= READ_ONCE(netdev_max_backlog))
538786 		return -ENOBUFS;
539787 
788
+	BUILD_BUG_ON(sizeof(struct xfrm_trans_cb) > sizeof(skb->cb));
789
+
540790 	XFRM_TRANS_SKB_CB(skb)->finish = finish;
791
+	XFRM_TRANS_SKB_CB(skb)->net = net;
541792 	__skb_queue_tail(&trans->queue, skb);
542793 	tasklet_schedule(&trans->tasklet);
543794 	return 0;
795
+}
796
+EXPORT_SYMBOL(xfrm_trans_queue_net);
797
+
798
+int xfrm_trans_queue(struct sk_buff *skb,
799
+		     int (*finish)(struct net *, struct sock *,
800
+				   struct sk_buff *))
801
+{
802
+	return xfrm_trans_queue_net(dev_net(skb->dev), skb, finish);
544803 }
545804 EXPORT_SYMBOL(xfrm_trans_queue);
546805 
....@@ -553,11 +812,6 @@
553812 	err = gro_cells_init(&gro_cells, &xfrm_napi_dev);
554813 	if (err)
555814 		gro_cells.cells = NULL;
556
-
557
-	secpath_cachep = kmem_cache_create("secpath_cache",
558
-					   sizeof(struct sec_path),
559
-					   0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
560
-					   NULL);
561815 
562816 	for_each_possible_cpu(i) {
563817 		struct xfrm_trans_tasklet *trans;