net/netfilter/nft_limit.c

   1 /*
   2  * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Development of this code funded by Astaro AG (http://www.astaro.com/)
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/spinlock.h>
  15 #include <linux/netlink.h>
  16 #include <linux/netfilter.h>
  17 #include <linux/netfilter/nf_tables.h>
  18 #include <net/netfilter/nf_tables.h>
  19
  20 static DEFINE_SPINLOCK(limit_lock);
  21
  22 struct nft_limit {
  23         u64             last;
  24         u64             tokens;
  25         u64             tokens_max;
  26         u64             rate;
  27         u64             nsecs;
  28         u32             burst;
  29         bool            invert;
  30 };
  31
  32 static inline bool nft_limit_eval(struct nft_limit *limit, u64 cost)
  33 {
  34         u64 now, tokens;
  35         s64 delta;
  36
  37         spin_lock_bh(&limit_lock);
  38         now = ktime_get_ns();
  39         tokens = limit->tokens + now - limit->last;
  40         if (tokens > limit->tokens_max)
  41                 tokens = limit->tokens_max;
  42
  43         limit->last = now;
  44         delta = tokens - cost;
  45         if (delta >= 0) {
  46                 limit->tokens = delta;
  47                 spin_unlock_bh(&limit_lock);
  48                 return limit->invert;
  49         }
  50         limit->tokens = tokens;
  51         spin_unlock_bh(&limit_lock);
  52         return !limit->invert;
  53 }
  54
  55 static int nft_limit_init(struct nft_limit *limit,
  56                           const struct nlattr * const tb[])
  57 {
  58         u64 unit;
  59
  60         if (tb[NFTA_LIMIT_RATE] == NULL ||
  61             tb[NFTA_LIMIT_UNIT] == NULL)
  62                 return -EINVAL;
  63
  64         limit->rate = be64_to_cpu(nla_get_be64(tb[NFTA_LIMIT_RATE]));
  65         unit = be64_to_cpu(nla_get_be64(tb[NFTA_LIMIT_UNIT]));
  66         limit->nsecs = unit * NSEC_PER_SEC;
  67         if (limit->rate == 0 || limit->nsecs < unit)
  68                 return -EOVERFLOW;
  69         limit->tokens = limit->tokens_max = limit->nsecs;
  70
  71         if (tb[NFTA_LIMIT_BURST]) {
  72                 u64 rate;
  73
  74                 limit->burst = ntohl(nla_get_be32(tb[NFTA_LIMIT_BURST]));
  75
  76                 rate = limit->rate + limit->burst;
  77                 if (rate < limit->rate)
  78                         return -EOVERFLOW;
  79
  80                 limit->rate = rate;
  81         }
  82         if (tb[NFTA_LIMIT_FLAGS]) {
  83                 u32 flags = ntohl(nla_get_be32(tb[NFTA_LIMIT_FLAGS]));
  84
  85                 if (flags & NFT_LIMIT_F_INV)
  86                         limit->invert = true;
  87         }
  88         limit->last = ktime_get_ns();
  89
  90         return 0;
  91 }
  92
  93 static int nft_limit_dump(struct sk_buff *skb, const struct nft_limit *limit,
  94                           enum nft_limit_type type)
  95 {
  96         u32 flags = limit->invert ? NFT_LIMIT_F_INV : 0;
  97         u64 secs = div_u64(limit->nsecs, NSEC_PER_SEC);
  98         u64 rate = limit->rate - limit->burst;
  99
 100         if (nla_put_be64(skb, NFTA_LIMIT_RATE, cpu_to_be64(rate),
 101                          NFTA_LIMIT_PAD) ||
 102             nla_put_be64(skb, NFTA_LIMIT_UNIT, cpu_to_be64(secs),
 103                          NFTA_LIMIT_PAD) ||
 104             nla_put_be32(skb, NFTA_LIMIT_BURST, htonl(limit->burst)) ||
 105             nla_put_be32(skb, NFTA_LIMIT_TYPE, htonl(type)) ||
 106             nla_put_be32(skb, NFTA_LIMIT_FLAGS, htonl(flags)))
 107                 goto nla_put_failure;
 108         return 0;
 109
 110 nla_put_failure:
 111         return -1;
 112 }
 113
 114 struct nft_limit_pkts {
 115         struct nft_limit        limit;
 116         u64                     cost;
 117 };
 118
 119 static void nft_limit_pkts_eval(const struct nft_expr *expr,
 120                                 struct nft_regs *regs,
 121                                 const struct nft_pktinfo *pkt)
 122 {
 123         struct nft_limit_pkts *priv = nft_expr_priv(expr);
 124
 125         if (nft_limit_eval(&priv->limit, priv->cost))
 126                 regs->verdict.code = NFT_BREAK;
 127 }
 128
 129 static const struct nla_policy nft_limit_policy[NFTA_LIMIT_MAX + 1] = {
 130         [NFTA_LIMIT_RATE]       = { .type = NLA_U64 },
 131         [NFTA_LIMIT_UNIT]       = { .type = NLA_U64 },
 132         [NFTA_LIMIT_BURST]      = { .type = NLA_U32 },
 133         [NFTA_LIMIT_TYPE]       = { .type = NLA_U32 },
 134         [NFTA_LIMIT_FLAGS]      = { .type = NLA_U32 },
 135 };
 136
 137 static int nft_limit_pkts_init(const struct nft_ctx *ctx,
 138                                const struct nft_expr *expr,
 139                                const struct nlattr * const tb[])
 140 {
 141         struct nft_limit_pkts *priv = nft_expr_priv(expr);
 142         int err;
 143
 144         err = nft_limit_init(&priv->limit, tb);
 145         if (err < 0)
 146                 return err;
 147
 148         priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);
 149         return 0;
 150 }
 151
 152 static int nft_limit_pkts_dump(struct sk_buff *skb, const struct nft_expr *expr)
 153 {
 154         const struct nft_limit_pkts *priv = nft_expr_priv(expr);
 155
 156         return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);
 157 }
 158
 159 static struct nft_expr_type nft_limit_type;
 160 static const struct nft_expr_ops nft_limit_pkts_ops = {
 161         .type           = &nft_limit_type,
 162         .size           = NFT_EXPR_SIZE(sizeof(struct nft_limit_pkts)),
 163         .eval           = nft_limit_pkts_eval,
 164         .init           = nft_limit_pkts_init,
 165         .dump           = nft_limit_pkts_dump,
 166 };
 167
 168 static void nft_limit_pkt_bytes_eval(const struct nft_expr *expr,
 169                                      struct nft_regs *regs,
 170                                      const struct nft_pktinfo *pkt)
 171 {
 172         struct nft_limit *priv = nft_expr_priv(expr);
 173         u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);
 174
 175         if (nft_limit_eval(priv, cost))
 176                 regs->verdict.code = NFT_BREAK;
 177 }
 178
 179 static int nft_limit_pkt_bytes_init(const struct nft_ctx *ctx,
 180                                     const struct nft_expr *expr,
 181                                     const struct nlattr * const tb[])
 182 {
 183         struct nft_limit *priv = nft_expr_priv(expr);
 184
 185         return nft_limit_init(priv, tb);
 186 }
 187
 188 static int nft_limit_pkt_bytes_dump(struct sk_buff *skb,
 189                                     const struct nft_expr *expr)
 190 {
 191         const struct nft_limit *priv = nft_expr_priv(expr);
 192
 193         return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
 194 }
 195
 196 static const struct nft_expr_ops nft_limit_pkt_bytes_ops = {
 197         .type           = &nft_limit_type,
 198         .size           = NFT_EXPR_SIZE(sizeof(struct nft_limit)),
 199         .eval           = nft_limit_pkt_bytes_eval,
 200         .init           = nft_limit_pkt_bytes_init,
 201         .dump           = nft_limit_pkt_bytes_dump,
 202 };
 203
 204 static const struct nft_expr_ops *
 205 nft_limit_select_ops(const struct nft_ctx *ctx,
 206                      const struct nlattr * const tb[])
 207 {
 208         if (tb[NFTA_LIMIT_TYPE] == NULL)
 209                 return &nft_limit_pkts_ops;
 210
 211         switch (ntohl(nla_get_be32(tb[NFTA_LIMIT_TYPE]))) {
 212         case NFT_LIMIT_PKTS:
 213                 return &nft_limit_pkts_ops;
 214         case NFT_LIMIT_PKT_BYTES:
 215                 return &nft_limit_pkt_bytes_ops;
 216         }
 217         return ERR_PTR(-EOPNOTSUPP);
 218 }
 219
 220 static struct nft_expr_type nft_limit_type __read_mostly = {
 221         .name           = "limit",
 222         .select_ops     = nft_limit_select_ops,
 223         .policy         = nft_limit_policy,
 224         .maxattr        = NFTA_LIMIT_MAX,
 225         .flags          = NFT_EXPR_STATEFUL,
 226         .owner          = THIS_MODULE,
 227 };
 228
 229 static int __init nft_limit_module_init(void)
 230 {
 231         return nft_register_expr(&nft_limit_type);
 232 }
 233
 234 static void __exit nft_limit_module_exit(void)
 235 {
 236         nft_unregister_expr(&nft_limit_type);
 237 }
 238
 239 module_init(nft_limit_module_init);
 240 module_exit(nft_limit_module_exit);
 241
 242 MODULE_LICENSE("GPL");
 243 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
 244 MODULE_ALIAS_NFT_EXPR("limit");