net/netfilter/nft_meta.c

   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 #if IS_ENABLED(CONFIG_NF_TABLES_BRIDGE) && IS_MODULE(CONFIG_NFT_BRIDGE_META)
 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 */