xref: /openbmc/linux/net/netfilter/nft_meta.c (revision 2f5947df) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
4  * Copyright (c) 2014 Intel Corporation
5  * Author: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
6  *
7  * Development of this code funded by Astaro AG (http://www.astaro.com/)
8  */
9 
10 #include <linux/kernel.h>
11 #include <linux/netlink.h>
12 #include <linux/netfilter.h>
13 #include <linux/netfilter/nf_tables.h>
14 #include <linux/in.h>
15 #include <linux/ip.h>
16 #include <linux/ipv6.h>
17 #include <linux/smp.h>
18 #include <linux/static_key.h>
19 #include <net/dst.h>
20 #include <net/sock.h>
21 #include <net/tcp_states.h> /* for TCP_TIME_WAIT */
22 #include <net/netfilter/nf_tables.h>
23 #include <net/netfilter/nf_tables_core.h>
24 #include <net/netfilter/nft_meta.h>
25 #include <net/netfilter/nf_tables_offload.h>
26 
27 #include <uapi/linux/netfilter_bridge.h> /* NF_BR_PRE_ROUTING */
28 
29 static DEFINE_PER_CPU(struct rnd_state, nft_prandom_state);
30 
31 void nft_meta_get_eval(const struct nft_expr *expr,
32 		       struct nft_regs *regs,
33 		       const struct nft_pktinfo *pkt)
34 {
35 	const struct nft_meta *priv = nft_expr_priv(expr);
36 	const struct sk_buff *skb = pkt->skb;
37 	const struct net_device *in = nft_in(pkt), *out = nft_out(pkt);
38 	struct sock *sk;
39 	u32 *dest = &regs->data[priv->dreg];
40 
41 	switch (priv->key) {
42 	case NFT_META_LEN:
43 		*dest = skb->len;
44 		break;
45 	case NFT_META_PROTOCOL:
46 		nft_reg_store16(dest, (__force u16)skb->protocol);
47 		break;
48 	case NFT_META_NFPROTO:
49 		nft_reg_store8(dest, nft_pf(pkt));
50 		break;
51 	case NFT_META_L4PROTO:
52 		if (!pkt->tprot_set)
53 			goto err;
54 		nft_reg_store8(dest, pkt->tprot);
55 		break;
56 	case NFT_META_PRIORITY:
57 		*dest = skb->priority;
58 		break;
59 	case NFT_META_MARK:
60 		*dest = skb->mark;
61 		break;
62 	case NFT_META_IIF:
63 		if (in == NULL)
64 			goto err;
65 		*dest = in->ifindex;
66 		break;
67 	case NFT_META_OIF:
68 		if (out == NULL)
69 			goto err;
70 		*dest = out->ifindex;
71 		break;
72 	case NFT_META_IIFNAME:
73 		if (in == NULL)
74 			goto err;
75 		strncpy((char *)dest, in->name, IFNAMSIZ);
76 		break;
77 	case NFT_META_OIFNAME:
78 		if (out == NULL)
79 			goto err;
80 		strncpy((char *)dest, out->name, IFNAMSIZ);
81 		break;
82 	case NFT_META_IIFTYPE:
83 		if (in == NULL)
84 			goto err;
85 		nft_reg_store16(dest, in->type);
86 		break;
87 	case NFT_META_OIFTYPE:
88 		if (out == NULL)
89 			goto err;
90 		nft_reg_store16(dest, out->type);
91 		break;
92 	case NFT_META_SKUID:
93 		sk = skb_to_full_sk(skb);
94 		if (!sk || !sk_fullsock(sk) ||
95 		    !net_eq(nft_net(pkt), sock_net(sk)))
96 			goto err;
97 
98 		read_lock_bh(&sk->sk_callback_lock);
99 		if (sk->sk_socket == NULL ||
100 		    sk->sk_socket->file == NULL) {
101 			read_unlock_bh(&sk->sk_callback_lock);
102 			goto err;
103 		}
104 
105 		*dest =	from_kuid_munged(&init_user_ns,
106 				sk->sk_socket->file->f_cred->fsuid);
107 		read_unlock_bh(&sk->sk_callback_lock);
108 		break;
109 	case NFT_META_SKGID:
110 		sk = skb_to_full_sk(skb);
111 		if (!sk || !sk_fullsock(sk) ||
112 		    !net_eq(nft_net(pkt), sock_net(sk)))
113 			goto err;
114 
115 		read_lock_bh(&sk->sk_callback_lock);
116 		if (sk->sk_socket == NULL ||
117 		    sk->sk_socket->file == NULL) {
118 			read_unlock_bh(&sk->sk_callback_lock);
119 			goto err;
120 		}
121 		*dest =	from_kgid_munged(&init_user_ns,
122 				 sk->sk_socket->file->f_cred->fsgid);
123 		read_unlock_bh(&sk->sk_callback_lock);
124 		break;
125 #ifdef CONFIG_IP_ROUTE_CLASSID
126 	case NFT_META_RTCLASSID: {
127 		const struct dst_entry *dst = skb_dst(skb);
128 
129 		if (dst == NULL)
130 			goto err;
131 		*dest = dst->tclassid;
132 		break;
133 	}
134 #endif
135 #ifdef CONFIG_NETWORK_SECMARK
136 	case NFT_META_SECMARK:
137 		*dest = skb->secmark;
138 		break;
139 #endif
140 	case NFT_META_PKTTYPE:
141 		if (skb->pkt_type != PACKET_LOOPBACK) {
142 			nft_reg_store8(dest, skb->pkt_type);
143 			break;
144 		}
145 
146 		switch (nft_pf(pkt)) {
147 		case NFPROTO_IPV4:
148 			if (ipv4_is_multicast(ip_hdr(skb)->daddr))
149 				nft_reg_store8(dest, PACKET_MULTICAST);
150 			else
151 				nft_reg_store8(dest, PACKET_BROADCAST);
152 			break;
153 		case NFPROTO_IPV6:
154 			nft_reg_store8(dest, PACKET_MULTICAST);
155 			break;
156 		case NFPROTO_NETDEV:
157 			switch (skb->protocol) {
158 			case htons(ETH_P_IP): {
159 				int noff = skb_network_offset(skb);
160 				struct iphdr *iph, _iph;
161 
162 				iph = skb_header_pointer(skb, noff,
163 							 sizeof(_iph), &_iph);
164 				if (!iph)
165 					goto err;
166 
167 				if (ipv4_is_multicast(iph->daddr))
168 					nft_reg_store8(dest, PACKET_MULTICAST);
169 				else
170 					nft_reg_store8(dest, PACKET_BROADCAST);
171 
172 				break;
173 			}
174 			case htons(ETH_P_IPV6):
175 				nft_reg_store8(dest, PACKET_MULTICAST);
176 				break;
177 			default:
178 				WARN_ON_ONCE(1);
179 				goto err;
180 			}
181 			break;
182 		default:
183 			WARN_ON_ONCE(1);
184 			goto err;
185 		}
186 		break;
187 	case NFT_META_CPU:
188 		*dest = raw_smp_processor_id();
189 		break;
190 	case NFT_META_IIFGROUP:
191 		if (in == NULL)
192 			goto err;
193 		*dest = in->group;
194 		break;
195 	case NFT_META_OIFGROUP:
196 		if (out == NULL)
197 			goto err;
198 		*dest = out->group;
199 		break;
200 #ifdef CONFIG_CGROUP_NET_CLASSID
201 	case NFT_META_CGROUP:
202 		sk = skb_to_full_sk(skb);
203 		if (!sk || !sk_fullsock(sk) ||
204 		    !net_eq(nft_net(pkt), sock_net(sk)))
205 			goto err;
206 		*dest = sock_cgroup_classid(&sk->sk_cgrp_data);
207 		break;
208 #endif
209 	case NFT_META_PRANDOM: {
210 		struct rnd_state *state = this_cpu_ptr(&nft_prandom_state);
211 		*dest = prandom_u32_state(state);
212 		break;
213 	}
214 #ifdef CONFIG_XFRM
215 	case NFT_META_SECPATH:
216 		nft_reg_store8(dest, secpath_exists(skb));
217 		break;
218 #endif
219 	case NFT_META_IIFKIND:
220 		if (in == NULL || in->rtnl_link_ops == NULL)
221 			goto err;
222 		strncpy((char *)dest, in->rtnl_link_ops->kind, IFNAMSIZ);
223 		break;
224 	case NFT_META_OIFKIND:
225 		if (out == NULL || out->rtnl_link_ops == NULL)
226 			goto err;
227 		strncpy((char *)dest, out->rtnl_link_ops->kind, IFNAMSIZ);
228 		break;
229 	default:
230 		WARN_ON(1);
231 		goto err;
232 	}
233 	return;
234 
235 err:
236 	regs->verdict.code = NFT_BREAK;
237 }
238 EXPORT_SYMBOL_GPL(nft_meta_get_eval);
239 
240 void nft_meta_set_eval(const struct nft_expr *expr,
241 		       struct nft_regs *regs,
242 		       const struct nft_pktinfo *pkt)
243 {
244 	const struct nft_meta *meta = nft_expr_priv(expr);
245 	struct sk_buff *skb = pkt->skb;
246 	u32 *sreg = &regs->data[meta->sreg];
247 	u32 value = *sreg;
248 	u8 value8;
249 
250 	switch (meta->key) {
251 	case NFT_META_MARK:
252 		skb->mark = value;
253 		break;
254 	case NFT_META_PRIORITY:
255 		skb->priority = value;
256 		break;
257 	case NFT_META_PKTTYPE:
258 		value8 = nft_reg_load8(sreg);
259 
260 		if (skb->pkt_type != value8 &&
261 		    skb_pkt_type_ok(value8) &&
262 		    skb_pkt_type_ok(skb->pkt_type))
263 			skb->pkt_type = value8;
264 		break;
265 	case NFT_META_NFTRACE:
266 		value8 = nft_reg_load8(sreg);
267 
268 		skb->nf_trace = !!value8;
269 		break;
270 #ifdef CONFIG_NETWORK_SECMARK
271 	case NFT_META_SECMARK:
272 		skb->secmark = value;
273 		break;
274 #endif
275 	default:
276 		WARN_ON(1);
277 	}
278 }
279 EXPORT_SYMBOL_GPL(nft_meta_set_eval);
280 
281 const struct nla_policy nft_meta_policy[NFTA_META_MAX + 1] = {
282 	[NFTA_META_DREG]	= { .type = NLA_U32 },
283 	[NFTA_META_KEY]		= { .type = NLA_U32 },
284 	[NFTA_META_SREG]	= { .type = NLA_U32 },
285 };
286 EXPORT_SYMBOL_GPL(nft_meta_policy);
287 
288 int nft_meta_get_init(const struct nft_ctx *ctx,
289 		      const struct nft_expr *expr,
290 		      const struct nlattr * const tb[])
291 {
292 	struct nft_meta *priv = nft_expr_priv(expr);
293 	unsigned int len;
294 
295 	priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
296 	switch (priv->key) {
297 	case NFT_META_PROTOCOL:
298 	case NFT_META_IIFTYPE:
299 	case NFT_META_OIFTYPE:
300 		len = sizeof(u16);
301 		break;
302 	case NFT_META_NFPROTO:
303 	case NFT_META_L4PROTO:
304 	case NFT_META_LEN:
305 	case NFT_META_PRIORITY:
306 	case NFT_META_MARK:
307 	case NFT_META_IIF:
308 	case NFT_META_OIF:
309 	case NFT_META_SKUID:
310 	case NFT_META_SKGID:
311 #ifdef CONFIG_IP_ROUTE_CLASSID
312 	case NFT_META_RTCLASSID:
313 #endif
314 #ifdef CONFIG_NETWORK_SECMARK
315 	case NFT_META_SECMARK:
316 #endif
317 	case NFT_META_PKTTYPE:
318 	case NFT_META_CPU:
319 	case NFT_META_IIFGROUP:
320 	case NFT_META_OIFGROUP:
321 #ifdef CONFIG_CGROUP_NET_CLASSID
322 	case NFT_META_CGROUP:
323 #endif
324 		len = sizeof(u32);
325 		break;
326 	case NFT_META_IIFNAME:
327 	case NFT_META_OIFNAME:
328 	case NFT_META_IIFKIND:
329 	case NFT_META_OIFKIND:
330 		len = IFNAMSIZ;
331 		break;
332 	case NFT_META_PRANDOM:
333 		prandom_init_once(&nft_prandom_state);
334 		len = sizeof(u32);
335 		break;
336 #ifdef CONFIG_XFRM
337 	case NFT_META_SECPATH:
338 		len = sizeof(u8);
339 		break;
340 #endif
341 	default:
342 		return -EOPNOTSUPP;
343 	}
344 
345 	priv->dreg = nft_parse_register(tb[NFTA_META_DREG]);
346 	return nft_validate_register_store(ctx, priv->dreg, NULL,
347 					   NFT_DATA_VALUE, len);
348 }
349 EXPORT_SYMBOL_GPL(nft_meta_get_init);
350 
351 static int nft_meta_get_validate(const struct nft_ctx *ctx,
352 				 const struct nft_expr *expr,
353 				 const struct nft_data **data)
354 {
355 #ifdef CONFIG_XFRM
356 	const struct nft_meta *priv = nft_expr_priv(expr);
357 	unsigned int hooks;
358 
359 	if (priv->key != NFT_META_SECPATH)
360 		return 0;
361 
362 	switch (ctx->family) {
363 	case NFPROTO_NETDEV:
364 		hooks = 1 << NF_NETDEV_INGRESS;
365 		break;
366 	case NFPROTO_IPV4:
367 	case NFPROTO_IPV6:
368 	case NFPROTO_INET:
369 		hooks = (1 << NF_INET_PRE_ROUTING) |
370 			(1 << NF_INET_LOCAL_IN) |
371 			(1 << NF_INET_FORWARD);
372 		break;
373 	default:
374 		return -EOPNOTSUPP;
375 	}
376 
377 	return nft_chain_validate_hooks(ctx->chain, hooks);
378 #else
379 	return 0;
380 #endif
381 }
382 
383 int nft_meta_set_validate(const struct nft_ctx *ctx,
384 			  const struct nft_expr *expr,
385 			  const struct nft_data **data)
386 {
387 	struct nft_meta *priv = nft_expr_priv(expr);
388 	unsigned int hooks;
389 
390 	if (priv->key != NFT_META_PKTTYPE)
391 		return 0;
392 
393 	switch (ctx->family) {
394 	case NFPROTO_BRIDGE:
395 		hooks = 1 << NF_BR_PRE_ROUTING;
396 		break;
397 	case NFPROTO_NETDEV:
398 		hooks = 1 << NF_NETDEV_INGRESS;
399 		break;
400 	case NFPROTO_IPV4:
401 	case NFPROTO_IPV6:
402 	case NFPROTO_INET:
403 		hooks = 1 << NF_INET_PRE_ROUTING;
404 		break;
405 	default:
406 		return -EOPNOTSUPP;
407 	}
408 
409 	return nft_chain_validate_hooks(ctx->chain, hooks);
410 }
411 EXPORT_SYMBOL_GPL(nft_meta_set_validate);
412 
413 int nft_meta_set_init(const struct nft_ctx *ctx,
414 		      const struct nft_expr *expr,
415 		      const struct nlattr * const tb[])
416 {
417 	struct nft_meta *priv = nft_expr_priv(expr);
418 	unsigned int len;
419 	int err;
420 
421 	priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
422 	switch (priv->key) {
423 	case NFT_META_MARK:
424 	case NFT_META_PRIORITY:
425 #ifdef CONFIG_NETWORK_SECMARK
426 	case NFT_META_SECMARK:
427 #endif
428 		len = sizeof(u32);
429 		break;
430 	case NFT_META_NFTRACE:
431 		len = sizeof(u8);
432 		break;
433 	case NFT_META_PKTTYPE:
434 		len = sizeof(u8);
435 		break;
436 	default:
437 		return -EOPNOTSUPP;
438 	}
439 
440 	priv->sreg = nft_parse_register(tb[NFTA_META_SREG]);
441 	err = nft_validate_register_load(priv->sreg, len);
442 	if (err < 0)
443 		return err;
444 
445 	if (priv->key == NFT_META_NFTRACE)
446 		static_branch_inc(&nft_trace_enabled);
447 
448 	return 0;
449 }
450 EXPORT_SYMBOL_GPL(nft_meta_set_init);
451 
452 int nft_meta_get_dump(struct sk_buff *skb,
453 		      const struct nft_expr *expr)
454 {
455 	const struct nft_meta *priv = nft_expr_priv(expr);
456 
457 	if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
458 		goto nla_put_failure;
459 	if (nft_dump_register(skb, NFTA_META_DREG, priv->dreg))
460 		goto nla_put_failure;
461 	return 0;
462 
463 nla_put_failure:
464 	return -1;
465 }
466 EXPORT_SYMBOL_GPL(nft_meta_get_dump);
467 
468 int nft_meta_set_dump(struct sk_buff *skb, const struct nft_expr *expr)
469 {
470 	const struct nft_meta *priv = nft_expr_priv(expr);
471 
472 	if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
473 		goto nla_put_failure;
474 	if (nft_dump_register(skb, NFTA_META_SREG, priv->sreg))
475 		goto nla_put_failure;
476 
477 	return 0;
478 
479 nla_put_failure:
480 	return -1;
481 }
482 EXPORT_SYMBOL_GPL(nft_meta_set_dump);
483 
484 void nft_meta_set_destroy(const struct nft_ctx *ctx,
485 			  const struct nft_expr *expr)
486 {
487 	const struct nft_meta *priv = nft_expr_priv(expr);
488 
489 	if (priv->key == NFT_META_NFTRACE)
490 		static_branch_dec(&nft_trace_enabled);
491 }
492 EXPORT_SYMBOL_GPL(nft_meta_set_destroy);
493 
494 static int nft_meta_get_offload(struct nft_offload_ctx *ctx,
495 				struct nft_flow_rule *flow,
496 				const struct nft_expr *expr)
497 {
498 	const struct nft_meta *priv = nft_expr_priv(expr);
499 	struct nft_offload_reg *reg = &ctx->regs[priv->dreg];
500 
501 	switch (priv->key) {
502 	case NFT_META_PROTOCOL:
503 		NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_BASIC, basic, n_proto,
504 				  sizeof(__u16), reg);
505 		nft_offload_set_dependency(ctx, NFT_OFFLOAD_DEP_NETWORK);
506 		break;
507 	case NFT_META_L4PROTO:
508 		NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_BASIC, basic, ip_proto,
509 				  sizeof(__u8), reg);
510 		nft_offload_set_dependency(ctx, NFT_OFFLOAD_DEP_TRANSPORT);
511 		break;
512 	default:
513 		return -EOPNOTSUPP;
514 	}
515 
516 	return 0;
517 }
518 
519 static const struct nft_expr_ops nft_meta_get_ops = {
520 	.type		= &nft_meta_type,
521 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_meta)),
522 	.eval		= nft_meta_get_eval,
523 	.init		= nft_meta_get_init,
524 	.dump		= nft_meta_get_dump,
525 	.validate	= nft_meta_get_validate,
526 	.offload	= nft_meta_get_offload,
527 };
528 
529 static const struct nft_expr_ops nft_meta_set_ops = {
530 	.type		= &nft_meta_type,
531 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_meta)),
532 	.eval		= nft_meta_set_eval,
533 	.init		= nft_meta_set_init,
534 	.destroy	= nft_meta_set_destroy,
535 	.dump		= nft_meta_set_dump,
536 	.validate	= nft_meta_set_validate,
537 };
538 
539 static const struct nft_expr_ops *
540 nft_meta_select_ops(const struct nft_ctx *ctx,
541 		    const struct nlattr * const tb[])
542 {
543 	if (tb[NFTA_META_KEY] == NULL)
544 		return ERR_PTR(-EINVAL);
545 
546 	if (tb[NFTA_META_DREG] && tb[NFTA_META_SREG])
547 		return ERR_PTR(-EINVAL);
548 
549 #ifdef CONFIG_NF_TABLES_BRIDGE
550 	if (ctx->family == NFPROTO_BRIDGE)
551 		return ERR_PTR(-EAGAIN);
552 #endif
553 	if (tb[NFTA_META_DREG])
554 		return &nft_meta_get_ops;
555 
556 	if (tb[NFTA_META_SREG])
557 		return &nft_meta_set_ops;
558 
559 	return ERR_PTR(-EINVAL);
560 }
561 
562 struct nft_expr_type nft_meta_type __read_mostly = {
563 	.name		= "meta",
564 	.select_ops	= nft_meta_select_ops,
565 	.policy		= nft_meta_policy,
566 	.maxattr	= NFTA_META_MAX,
567 	.owner		= THIS_MODULE,
568 };
569 
570 #ifdef CONFIG_NETWORK_SECMARK
571 struct nft_secmark {
572 	u32 secid;
573 	char *ctx;
574 };
575 
576 static const struct nla_policy nft_secmark_policy[NFTA_SECMARK_MAX + 1] = {
577 	[NFTA_SECMARK_CTX]     = { .type = NLA_STRING, .len = NFT_SECMARK_CTX_MAXLEN },
578 };
579 
580 static int nft_secmark_compute_secid(struct nft_secmark *priv)
581 {
582 	u32 tmp_secid = 0;
583 	int err;
584 
585 	err = security_secctx_to_secid(priv->ctx, strlen(priv->ctx), &tmp_secid);
586 	if (err)
587 		return err;
588 
589 	if (!tmp_secid)
590 		return -ENOENT;
591 
592 	err = security_secmark_relabel_packet(tmp_secid);
593 	if (err)
594 		return err;
595 
596 	priv->secid = tmp_secid;
597 	return 0;
598 }
599 
600 static void nft_secmark_obj_eval(struct nft_object *obj, struct nft_regs *regs,
601 				 const struct nft_pktinfo *pkt)
602 {
603 	const struct nft_secmark *priv = nft_obj_data(obj);
604 	struct sk_buff *skb = pkt->skb;
605 
606 	skb->secmark = priv->secid;
607 }
608 
609 static int nft_secmark_obj_init(const struct nft_ctx *ctx,
610 				const struct nlattr * const tb[],
611 				struct nft_object *obj)
612 {
613 	struct nft_secmark *priv = nft_obj_data(obj);
614 	int err;
615 
616 	if (tb[NFTA_SECMARK_CTX] == NULL)
617 		return -EINVAL;
618 
619 	priv->ctx = nla_strdup(tb[NFTA_SECMARK_CTX], GFP_KERNEL);
620 	if (!priv->ctx)
621 		return -ENOMEM;
622 
623 	err = nft_secmark_compute_secid(priv);
624 	if (err) {
625 		kfree(priv->ctx);
626 		return err;
627 	}
628 
629 	security_secmark_refcount_inc();
630 
631 	return 0;
632 }
633 
634 static int nft_secmark_obj_dump(struct sk_buff *skb, struct nft_object *obj,
635 				bool reset)
636 {
637 	struct nft_secmark *priv = nft_obj_data(obj);
638 	int err;
639 
640 	if (nla_put_string(skb, NFTA_SECMARK_CTX, priv->ctx))
641 		return -1;
642 
643 	if (reset) {
644 		err = nft_secmark_compute_secid(priv);
645 		if (err)
646 			return err;
647 	}
648 
649 	return 0;
650 }
651 
652 static void nft_secmark_obj_destroy(const struct nft_ctx *ctx, struct nft_object *obj)
653 {
654 	struct nft_secmark *priv = nft_obj_data(obj);
655 
656 	security_secmark_refcount_dec();
657 
658 	kfree(priv->ctx);
659 }
660 
661 static const struct nft_object_ops nft_secmark_obj_ops = {
662 	.type		= &nft_secmark_obj_type,
663 	.size		= sizeof(struct nft_secmark),
664 	.init		= nft_secmark_obj_init,
665 	.eval		= nft_secmark_obj_eval,
666 	.dump		= nft_secmark_obj_dump,
667 	.destroy	= nft_secmark_obj_destroy,
668 };
669 struct nft_object_type nft_secmark_obj_type __read_mostly = {
670 	.type		= NFT_OBJECT_SECMARK,
671 	.ops		= &nft_secmark_obj_ops,
672 	.maxattr	= NFTA_SECMARK_MAX,
673 	.policy		= nft_secmark_policy,
674 	.owner		= THIS_MODULE,
675 };
676 #endif /* CONFIG_NETWORK_SECMARK */
677