Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
4 *
5 * Development of this code funded by Astaro AG (http://www.astaro.com/)
6 */
7
8#include <linux/kernel.h>
9#include <linux/init.h>
10#include <linux/module.h>
11#include <linux/spinlock.h>
12#include <linux/netlink.h>
13#include <linux/netfilter.h>
14#include <linux/netfilter/nf_tables.h>
15#include <net/netfilter/nf_tables.h>
16
17struct nft_limit {
18 spinlock_t lock;
19 u64 last;
20 u64 tokens;
21 u64 tokens_max;
22 u64 rate;
23 u64 nsecs;
24 u32 burst;
25 bool invert;
26};
27
28static inline bool nft_limit_eval(struct nft_limit *limit, u64 cost)
29{
30 u64 now, tokens;
31 s64 delta;
32
33 spin_lock_bh(&limit->lock);
34 now = ktime_get_ns();
35 tokens = limit->tokens + now - limit->last;
36 if (tokens > limit->tokens_max)
37 tokens = limit->tokens_max;
38
39 limit->last = now;
40 delta = tokens - cost;
41 if (delta >= 0) {
42 limit->tokens = delta;
43 spin_unlock_bh(&limit->lock);
44 return limit->invert;
45 }
46 limit->tokens = tokens;
47 spin_unlock_bh(&limit->lock);
48 return !limit->invert;
49}
50
51/* Use same default as in iptables. */
52#define NFT_LIMIT_PKT_BURST_DEFAULT 5
53
54static int nft_limit_init(struct nft_limit *limit,
55 const struct nlattr * const tb[], bool pkts)
56{
57 u64 unit, tokens;
58
59 if (tb[NFTA_LIMIT_RATE] == NULL ||
60 tb[NFTA_LIMIT_UNIT] == NULL)
61 return -EINVAL;
62
63 limit->rate = be64_to_cpu(nla_get_be64(tb[NFTA_LIMIT_RATE]));
64 unit = be64_to_cpu(nla_get_be64(tb[NFTA_LIMIT_UNIT]));
65 limit->nsecs = unit * NSEC_PER_SEC;
66 if (limit->rate == 0 || limit->nsecs < unit)
67 return -EOVERFLOW;
68
69 if (tb[NFTA_LIMIT_BURST])
70 limit->burst = ntohl(nla_get_be32(tb[NFTA_LIMIT_BURST]));
71
72 if (pkts && limit->burst == 0)
73 limit->burst = NFT_LIMIT_PKT_BURST_DEFAULT;
74
75 if (limit->rate + limit->burst < limit->rate)
76 return -EOVERFLOW;
77
78 if (pkts) {
79 tokens = div64_u64(limit->nsecs, limit->rate) * limit->burst;
80 } else {
81 /* The token bucket size limits the number of tokens can be
82 * accumulated. tokens_max specifies the bucket size.
83 * tokens_max = unit * (rate + burst) / rate.
84 */
85 tokens = div64_u64(limit->nsecs * (limit->rate + limit->burst),
86 limit->rate);
87 }
88
89 limit->tokens = tokens;
90 limit->tokens_max = limit->tokens;
91
92 if (tb[NFTA_LIMIT_FLAGS]) {
93 u32 flags = ntohl(nla_get_be32(tb[NFTA_LIMIT_FLAGS]));
94
95 if (flags & NFT_LIMIT_F_INV)
96 limit->invert = true;
97 }
98 limit->last = ktime_get_ns();
99 spin_lock_init(&limit->lock);
100
101 return 0;
102}
103
104static int nft_limit_dump(struct sk_buff *skb, const struct nft_limit *limit,
105 enum nft_limit_type type)
106{
107 u32 flags = limit->invert ? NFT_LIMIT_F_INV : 0;
108 u64 secs = div_u64(limit->nsecs, NSEC_PER_SEC);
109
110 if (nla_put_be64(skb, NFTA_LIMIT_RATE, cpu_to_be64(limit->rate),
111 NFTA_LIMIT_PAD) ||
112 nla_put_be64(skb, NFTA_LIMIT_UNIT, cpu_to_be64(secs),
113 NFTA_LIMIT_PAD) ||
114 nla_put_be32(skb, NFTA_LIMIT_BURST, htonl(limit->burst)) ||
115 nla_put_be32(skb, NFTA_LIMIT_TYPE, htonl(type)) ||
116 nla_put_be32(skb, NFTA_LIMIT_FLAGS, htonl(flags)))
117 goto nla_put_failure;
118 return 0;
119
120nla_put_failure:
121 return -1;
122}
123
124struct nft_limit_pkts {
125 struct nft_limit limit;
126 u64 cost;
127};
128
129static void nft_limit_pkts_eval(const struct nft_expr *expr,
130 struct nft_regs *regs,
131 const struct nft_pktinfo *pkt)
132{
133 struct nft_limit_pkts *priv = nft_expr_priv(expr);
134
135 if (nft_limit_eval(&priv->limit, priv->cost))
136 regs->verdict.code = NFT_BREAK;
137}
138
139static const struct nla_policy nft_limit_policy[NFTA_LIMIT_MAX + 1] = {
140 [NFTA_LIMIT_RATE] = { .type = NLA_U64 },
141 [NFTA_LIMIT_UNIT] = { .type = NLA_U64 },
142 [NFTA_LIMIT_BURST] = { .type = NLA_U32 },
143 [NFTA_LIMIT_TYPE] = { .type = NLA_U32 },
144 [NFTA_LIMIT_FLAGS] = { .type = NLA_U32 },
145};
146
147static int nft_limit_pkts_init(const struct nft_ctx *ctx,
148 const struct nft_expr *expr,
149 const struct nlattr * const tb[])
150{
151 struct nft_limit_pkts *priv = nft_expr_priv(expr);
152 int err;
153
154 err = nft_limit_init(&priv->limit, tb, true);
155 if (err < 0)
156 return err;
157
158 priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);
159 return 0;
160}
161
162static int nft_limit_pkts_dump(struct sk_buff *skb, const struct nft_expr *expr)
163{
164 const struct nft_limit_pkts *priv = nft_expr_priv(expr);
165
166 return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);
167}
168
169static struct nft_expr_type nft_limit_type;
170static const struct nft_expr_ops nft_limit_pkts_ops = {
171 .type = &nft_limit_type,
172 .size = NFT_EXPR_SIZE(sizeof(struct nft_limit_pkts)),
173 .eval = nft_limit_pkts_eval,
174 .init = nft_limit_pkts_init,
175 .dump = nft_limit_pkts_dump,
176};
177
178static void nft_limit_bytes_eval(const struct nft_expr *expr,
179 struct nft_regs *regs,
180 const struct nft_pktinfo *pkt)
181{
182 struct nft_limit *priv = nft_expr_priv(expr);
183 u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);
184
185 if (nft_limit_eval(priv, cost))
186 regs->verdict.code = NFT_BREAK;
187}
188
189static int nft_limit_bytes_init(const struct nft_ctx *ctx,
190 const struct nft_expr *expr,
191 const struct nlattr * const tb[])
192{
193 struct nft_limit *priv = nft_expr_priv(expr);
194
195 return nft_limit_init(priv, tb, false);
196}
197
198static int nft_limit_bytes_dump(struct sk_buff *skb,
199 const struct nft_expr *expr)
200{
201 const struct nft_limit *priv = nft_expr_priv(expr);
202
203 return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
204}
205
206static const struct nft_expr_ops nft_limit_bytes_ops = {
207 .type = &nft_limit_type,
208 .size = NFT_EXPR_SIZE(sizeof(struct nft_limit)),
209 .eval = nft_limit_bytes_eval,
210 .init = nft_limit_bytes_init,
211 .dump = nft_limit_bytes_dump,
212};
213
214static const struct nft_expr_ops *
215nft_limit_select_ops(const struct nft_ctx *ctx,
216 const struct nlattr * const tb[])
217{
218 if (tb[NFTA_LIMIT_TYPE] == NULL)
219 return &nft_limit_pkts_ops;
220
221 switch (ntohl(nla_get_be32(tb[NFTA_LIMIT_TYPE]))) {
222 case NFT_LIMIT_PKTS:
223 return &nft_limit_pkts_ops;
224 case NFT_LIMIT_PKT_BYTES:
225 return &nft_limit_bytes_ops;
226 }
227 return ERR_PTR(-EOPNOTSUPP);
228}
229
230static struct nft_expr_type nft_limit_type __read_mostly = {
231 .name = "limit",
232 .select_ops = nft_limit_select_ops,
233 .policy = nft_limit_policy,
234 .maxattr = NFTA_LIMIT_MAX,
235 .flags = NFT_EXPR_STATEFUL,
236 .owner = THIS_MODULE,
237};
238
239static void nft_limit_obj_pkts_eval(struct nft_object *obj,
240 struct nft_regs *regs,
241 const struct nft_pktinfo *pkt)
242{
243 struct nft_limit_pkts *priv = nft_obj_data(obj);
244
245 if (nft_limit_eval(&priv->limit, priv->cost))
246 regs->verdict.code = NFT_BREAK;
247}
248
249static int nft_limit_obj_pkts_init(const struct nft_ctx *ctx,
250 const struct nlattr * const tb[],
251 struct nft_object *obj)
252{
253 struct nft_limit_pkts *priv = nft_obj_data(obj);
254 int err;
255
256 err = nft_limit_init(&priv->limit, tb, true);
257 if (err < 0)
258 return err;
259
260 priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);
261 return 0;
262}
263
264static int nft_limit_obj_pkts_dump(struct sk_buff *skb,
265 struct nft_object *obj,
266 bool reset)
267{
268 const struct nft_limit_pkts *priv = nft_obj_data(obj);
269
270 return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);
271}
272
273static struct nft_object_type nft_limit_obj_type;
274static const struct nft_object_ops nft_limit_obj_pkts_ops = {
275 .type = &nft_limit_obj_type,
276 .size = NFT_EXPR_SIZE(sizeof(struct nft_limit_pkts)),
277 .init = nft_limit_obj_pkts_init,
278 .eval = nft_limit_obj_pkts_eval,
279 .dump = nft_limit_obj_pkts_dump,
280};
281
282static void nft_limit_obj_bytes_eval(struct nft_object *obj,
283 struct nft_regs *regs,
284 const struct nft_pktinfo *pkt)
285{
286 struct nft_limit *priv = nft_obj_data(obj);
287 u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);
288
289 if (nft_limit_eval(priv, cost))
290 regs->verdict.code = NFT_BREAK;
291}
292
293static int nft_limit_obj_bytes_init(const struct nft_ctx *ctx,
294 const struct nlattr * const tb[],
295 struct nft_object *obj)
296{
297 struct nft_limit *priv = nft_obj_data(obj);
298
299 return nft_limit_init(priv, tb, false);
300}
301
302static int nft_limit_obj_bytes_dump(struct sk_buff *skb,
303 struct nft_object *obj,
304 bool reset)
305{
306 const struct nft_limit *priv = nft_obj_data(obj);
307
308 return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
309}
310
311static struct nft_object_type nft_limit_obj_type;
312static const struct nft_object_ops nft_limit_obj_bytes_ops = {
313 .type = &nft_limit_obj_type,
314 .size = sizeof(struct nft_limit),
315 .init = nft_limit_obj_bytes_init,
316 .eval = nft_limit_obj_bytes_eval,
317 .dump = nft_limit_obj_bytes_dump,
318};
319
320static const struct nft_object_ops *
321nft_limit_obj_select_ops(const struct nft_ctx *ctx,
322 const struct nlattr * const tb[])
323{
324 if (!tb[NFTA_LIMIT_TYPE])
325 return &nft_limit_obj_pkts_ops;
326
327 switch (ntohl(nla_get_be32(tb[NFTA_LIMIT_TYPE]))) {
328 case NFT_LIMIT_PKTS:
329 return &nft_limit_obj_pkts_ops;
330 case NFT_LIMIT_PKT_BYTES:
331 return &nft_limit_obj_bytes_ops;
332 }
333 return ERR_PTR(-EOPNOTSUPP);
334}
335
336static struct nft_object_type nft_limit_obj_type __read_mostly = {
337 .select_ops = nft_limit_obj_select_ops,
338 .type = NFT_OBJECT_LIMIT,
339 .maxattr = NFTA_LIMIT_MAX,
340 .policy = nft_limit_policy,
341 .owner = THIS_MODULE,
342};
343
344static int __init nft_limit_module_init(void)
345{
346 int err;
347
348 err = nft_register_obj(&nft_limit_obj_type);
349 if (err < 0)
350 return err;
351
352 err = nft_register_expr(&nft_limit_type);
353 if (err < 0)
354 goto err1;
355
356 return 0;
357err1:
358 nft_unregister_obj(&nft_limit_obj_type);
359 return err;
360}
361
362static void __exit nft_limit_module_exit(void)
363{
364 nft_unregister_expr(&nft_limit_type);
365 nft_unregister_obj(&nft_limit_obj_type);
366}
367
368module_init(nft_limit_module_init);
369module_exit(nft_limit_module_exit);
370
371MODULE_LICENSE("GPL");
372MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
373MODULE_ALIAS_NFT_EXPR("limit");
374MODULE_ALIAS_NFT_OBJ(NFT_OBJECT_LIMIT);
375MODULE_DESCRIPTION("nftables limit expression support");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
4 *
5 * Development of this code funded by Astaro AG (http://www.astaro.com/)
6 */
7
8#include <linux/kernel.h>
9#include <linux/init.h>
10#include <linux/module.h>
11#include <linux/spinlock.h>
12#include <linux/netlink.h>
13#include <linux/netfilter.h>
14#include <linux/netfilter/nf_tables.h>
15#include <net/netfilter/nf_tables.h>
16
17struct nft_limit {
18 spinlock_t lock;
19 u64 last;
20 u64 tokens;
21};
22
23struct nft_limit_priv {
24 struct nft_limit *limit;
25 u64 tokens_max;
26 u64 rate;
27 u64 nsecs;
28 u32 burst;
29 bool invert;
30};
31
32static inline bool nft_limit_eval(struct nft_limit_priv *priv, u64 cost)
33{
34 u64 now, tokens;
35 s64 delta;
36
37 spin_lock_bh(&priv->limit->lock);
38 now = ktime_get_ns();
39 tokens = priv->limit->tokens + now - priv->limit->last;
40 if (tokens > priv->tokens_max)
41 tokens = priv->tokens_max;
42
43 priv->limit->last = now;
44 delta = tokens - cost;
45 if (delta >= 0) {
46 priv->limit->tokens = delta;
47 spin_unlock_bh(&priv->limit->lock);
48 return priv->invert;
49 }
50 priv->limit->tokens = tokens;
51 spin_unlock_bh(&priv->limit->lock);
52 return !priv->invert;
53}
54
55/* Use same default as in iptables. */
56#define NFT_LIMIT_PKT_BURST_DEFAULT 5
57
58static int nft_limit_init(struct nft_limit_priv *priv,
59 const struct nlattr * const tb[], bool pkts)
60{
61 u64 unit, tokens, rate_with_burst;
62 bool invert = false;
63
64 if (tb[NFTA_LIMIT_RATE] == NULL ||
65 tb[NFTA_LIMIT_UNIT] == NULL)
66 return -EINVAL;
67
68 priv->rate = be64_to_cpu(nla_get_be64(tb[NFTA_LIMIT_RATE]));
69 if (priv->rate == 0)
70 return -EINVAL;
71
72 unit = be64_to_cpu(nla_get_be64(tb[NFTA_LIMIT_UNIT]));
73 if (check_mul_overflow(unit, NSEC_PER_SEC, &priv->nsecs))
74 return -EOVERFLOW;
75
76 if (tb[NFTA_LIMIT_BURST])
77 priv->burst = ntohl(nla_get_be32(tb[NFTA_LIMIT_BURST]));
78
79 if (pkts && priv->burst == 0)
80 priv->burst = NFT_LIMIT_PKT_BURST_DEFAULT;
81
82 if (check_add_overflow(priv->rate, priv->burst, &rate_with_burst))
83 return -EOVERFLOW;
84
85 if (pkts) {
86 u64 tmp = div64_u64(priv->nsecs, priv->rate);
87
88 if (check_mul_overflow(tmp, priv->burst, &tokens))
89 return -EOVERFLOW;
90 } else {
91 u64 tmp;
92
93 /* The token bucket size limits the number of tokens can be
94 * accumulated. tokens_max specifies the bucket size.
95 * tokens_max = unit * (rate + burst) / rate.
96 */
97 if (check_mul_overflow(priv->nsecs, rate_with_burst, &tmp))
98 return -EOVERFLOW;
99
100 tokens = div64_u64(tmp, priv->rate);
101 }
102
103 if (tb[NFTA_LIMIT_FLAGS]) {
104 u32 flags = ntohl(nla_get_be32(tb[NFTA_LIMIT_FLAGS]));
105
106 if (flags & ~NFT_LIMIT_F_INV)
107 return -EOPNOTSUPP;
108
109 if (flags & NFT_LIMIT_F_INV)
110 invert = true;
111 }
112
113 priv->limit = kmalloc(sizeof(*priv->limit), GFP_KERNEL_ACCOUNT);
114 if (!priv->limit)
115 return -ENOMEM;
116
117 priv->limit->tokens = tokens;
118 priv->tokens_max = priv->limit->tokens;
119 priv->invert = invert;
120 priv->limit->last = ktime_get_ns();
121 spin_lock_init(&priv->limit->lock);
122
123 return 0;
124}
125
126static int nft_limit_dump(struct sk_buff *skb, const struct nft_limit_priv *priv,
127 enum nft_limit_type type)
128{
129 u32 flags = priv->invert ? NFT_LIMIT_F_INV : 0;
130 u64 secs = div_u64(priv->nsecs, NSEC_PER_SEC);
131
132 if (nla_put_be64(skb, NFTA_LIMIT_RATE, cpu_to_be64(priv->rate),
133 NFTA_LIMIT_PAD) ||
134 nla_put_be64(skb, NFTA_LIMIT_UNIT, cpu_to_be64(secs),
135 NFTA_LIMIT_PAD) ||
136 nla_put_be32(skb, NFTA_LIMIT_BURST, htonl(priv->burst)) ||
137 nla_put_be32(skb, NFTA_LIMIT_TYPE, htonl(type)) ||
138 nla_put_be32(skb, NFTA_LIMIT_FLAGS, htonl(flags)))
139 goto nla_put_failure;
140 return 0;
141
142nla_put_failure:
143 return -1;
144}
145
146static void nft_limit_destroy(const struct nft_ctx *ctx,
147 const struct nft_limit_priv *priv)
148{
149 kfree(priv->limit);
150}
151
152static int nft_limit_clone(struct nft_limit_priv *priv_dst,
153 const struct nft_limit_priv *priv_src, gfp_t gfp)
154{
155 priv_dst->tokens_max = priv_src->tokens_max;
156 priv_dst->rate = priv_src->rate;
157 priv_dst->nsecs = priv_src->nsecs;
158 priv_dst->burst = priv_src->burst;
159 priv_dst->invert = priv_src->invert;
160
161 priv_dst->limit = kmalloc(sizeof(*priv_dst->limit), gfp);
162 if (!priv_dst->limit)
163 return -ENOMEM;
164
165 spin_lock_init(&priv_dst->limit->lock);
166 priv_dst->limit->tokens = priv_src->tokens_max;
167 priv_dst->limit->last = ktime_get_ns();
168
169 return 0;
170}
171
172struct nft_limit_priv_pkts {
173 struct nft_limit_priv limit;
174 u64 cost;
175};
176
177static void nft_limit_pkts_eval(const struct nft_expr *expr,
178 struct nft_regs *regs,
179 const struct nft_pktinfo *pkt)
180{
181 struct nft_limit_priv_pkts *priv = nft_expr_priv(expr);
182
183 if (nft_limit_eval(&priv->limit, priv->cost))
184 regs->verdict.code = NFT_BREAK;
185}
186
187static const struct nla_policy nft_limit_policy[NFTA_LIMIT_MAX + 1] = {
188 [NFTA_LIMIT_RATE] = { .type = NLA_U64 },
189 [NFTA_LIMIT_UNIT] = { .type = NLA_U64 },
190 [NFTA_LIMIT_BURST] = { .type = NLA_U32 },
191 [NFTA_LIMIT_TYPE] = { .type = NLA_U32 },
192 [NFTA_LIMIT_FLAGS] = { .type = NLA_U32 },
193};
194
195static int nft_limit_pkts_init(const struct nft_ctx *ctx,
196 const struct nft_expr *expr,
197 const struct nlattr * const tb[])
198{
199 struct nft_limit_priv_pkts *priv = nft_expr_priv(expr);
200 int err;
201
202 err = nft_limit_init(&priv->limit, tb, true);
203 if (err < 0)
204 return err;
205
206 priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);
207 return 0;
208}
209
210static int nft_limit_pkts_dump(struct sk_buff *skb,
211 const struct nft_expr *expr, bool reset)
212{
213 const struct nft_limit_priv_pkts *priv = nft_expr_priv(expr);
214
215 return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);
216}
217
218static void nft_limit_pkts_destroy(const struct nft_ctx *ctx,
219 const struct nft_expr *expr)
220{
221 const struct nft_limit_priv_pkts *priv = nft_expr_priv(expr);
222
223 nft_limit_destroy(ctx, &priv->limit);
224}
225
226static int nft_limit_pkts_clone(struct nft_expr *dst, const struct nft_expr *src,
227 gfp_t gfp)
228{
229 struct nft_limit_priv_pkts *priv_dst = nft_expr_priv(dst);
230 struct nft_limit_priv_pkts *priv_src = nft_expr_priv(src);
231
232 priv_dst->cost = priv_src->cost;
233
234 return nft_limit_clone(&priv_dst->limit, &priv_src->limit, gfp);
235}
236
237static struct nft_expr_type nft_limit_type;
238static const struct nft_expr_ops nft_limit_pkts_ops = {
239 .type = &nft_limit_type,
240 .size = NFT_EXPR_SIZE(sizeof(struct nft_limit_priv_pkts)),
241 .eval = nft_limit_pkts_eval,
242 .init = nft_limit_pkts_init,
243 .destroy = nft_limit_pkts_destroy,
244 .clone = nft_limit_pkts_clone,
245 .dump = nft_limit_pkts_dump,
246 .reduce = NFT_REDUCE_READONLY,
247};
248
249static void nft_limit_bytes_eval(const struct nft_expr *expr,
250 struct nft_regs *regs,
251 const struct nft_pktinfo *pkt)
252{
253 struct nft_limit_priv *priv = nft_expr_priv(expr);
254 u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);
255
256 if (nft_limit_eval(priv, cost))
257 regs->verdict.code = NFT_BREAK;
258}
259
260static int nft_limit_bytes_init(const struct nft_ctx *ctx,
261 const struct nft_expr *expr,
262 const struct nlattr * const tb[])
263{
264 struct nft_limit_priv *priv = nft_expr_priv(expr);
265
266 return nft_limit_init(priv, tb, false);
267}
268
269static int nft_limit_bytes_dump(struct sk_buff *skb,
270 const struct nft_expr *expr, bool reset)
271{
272 const struct nft_limit_priv *priv = nft_expr_priv(expr);
273
274 return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
275}
276
277static void nft_limit_bytes_destroy(const struct nft_ctx *ctx,
278 const struct nft_expr *expr)
279{
280 const struct nft_limit_priv *priv = nft_expr_priv(expr);
281
282 nft_limit_destroy(ctx, priv);
283}
284
285static int nft_limit_bytes_clone(struct nft_expr *dst, const struct nft_expr *src,
286 gfp_t gfp)
287{
288 struct nft_limit_priv *priv_dst = nft_expr_priv(dst);
289 struct nft_limit_priv *priv_src = nft_expr_priv(src);
290
291 return nft_limit_clone(priv_dst, priv_src, gfp);
292}
293
294static const struct nft_expr_ops nft_limit_bytes_ops = {
295 .type = &nft_limit_type,
296 .size = NFT_EXPR_SIZE(sizeof(struct nft_limit_priv)),
297 .eval = nft_limit_bytes_eval,
298 .init = nft_limit_bytes_init,
299 .dump = nft_limit_bytes_dump,
300 .clone = nft_limit_bytes_clone,
301 .destroy = nft_limit_bytes_destroy,
302 .reduce = NFT_REDUCE_READONLY,
303};
304
305static const struct nft_expr_ops *
306nft_limit_select_ops(const struct nft_ctx *ctx,
307 const struct nlattr * const tb[])
308{
309 if (tb[NFTA_LIMIT_TYPE] == NULL)
310 return &nft_limit_pkts_ops;
311
312 switch (ntohl(nla_get_be32(tb[NFTA_LIMIT_TYPE]))) {
313 case NFT_LIMIT_PKTS:
314 return &nft_limit_pkts_ops;
315 case NFT_LIMIT_PKT_BYTES:
316 return &nft_limit_bytes_ops;
317 }
318 return ERR_PTR(-EOPNOTSUPP);
319}
320
321static struct nft_expr_type nft_limit_type __read_mostly = {
322 .name = "limit",
323 .select_ops = nft_limit_select_ops,
324 .policy = nft_limit_policy,
325 .maxattr = NFTA_LIMIT_MAX,
326 .flags = NFT_EXPR_STATEFUL,
327 .owner = THIS_MODULE,
328};
329
330static void nft_limit_obj_pkts_eval(struct nft_object *obj,
331 struct nft_regs *regs,
332 const struct nft_pktinfo *pkt)
333{
334 struct nft_limit_priv_pkts *priv = nft_obj_data(obj);
335
336 if (nft_limit_eval(&priv->limit, priv->cost))
337 regs->verdict.code = NFT_BREAK;
338}
339
340static int nft_limit_obj_pkts_init(const struct nft_ctx *ctx,
341 const struct nlattr * const tb[],
342 struct nft_object *obj)
343{
344 struct nft_limit_priv_pkts *priv = nft_obj_data(obj);
345 int err;
346
347 err = nft_limit_init(&priv->limit, tb, true);
348 if (err < 0)
349 return err;
350
351 priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);
352 return 0;
353}
354
355static int nft_limit_obj_pkts_dump(struct sk_buff *skb,
356 struct nft_object *obj,
357 bool reset)
358{
359 const struct nft_limit_priv_pkts *priv = nft_obj_data(obj);
360
361 return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);
362}
363
364static void nft_limit_obj_pkts_destroy(const struct nft_ctx *ctx,
365 struct nft_object *obj)
366{
367 struct nft_limit_priv_pkts *priv = nft_obj_data(obj);
368
369 nft_limit_destroy(ctx, &priv->limit);
370}
371
372static struct nft_object_type nft_limit_obj_type;
373static const struct nft_object_ops nft_limit_obj_pkts_ops = {
374 .type = &nft_limit_obj_type,
375 .size = NFT_EXPR_SIZE(sizeof(struct nft_limit_priv_pkts)),
376 .init = nft_limit_obj_pkts_init,
377 .destroy = nft_limit_obj_pkts_destroy,
378 .eval = nft_limit_obj_pkts_eval,
379 .dump = nft_limit_obj_pkts_dump,
380};
381
382static void nft_limit_obj_bytes_eval(struct nft_object *obj,
383 struct nft_regs *regs,
384 const struct nft_pktinfo *pkt)
385{
386 struct nft_limit_priv *priv = nft_obj_data(obj);
387 u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);
388
389 if (nft_limit_eval(priv, cost))
390 regs->verdict.code = NFT_BREAK;
391}
392
393static int nft_limit_obj_bytes_init(const struct nft_ctx *ctx,
394 const struct nlattr * const tb[],
395 struct nft_object *obj)
396{
397 struct nft_limit_priv *priv = nft_obj_data(obj);
398
399 return nft_limit_init(priv, tb, false);
400}
401
402static int nft_limit_obj_bytes_dump(struct sk_buff *skb,
403 struct nft_object *obj,
404 bool reset)
405{
406 const struct nft_limit_priv *priv = nft_obj_data(obj);
407
408 return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
409}
410
411static void nft_limit_obj_bytes_destroy(const struct nft_ctx *ctx,
412 struct nft_object *obj)
413{
414 struct nft_limit_priv *priv = nft_obj_data(obj);
415
416 nft_limit_destroy(ctx, priv);
417}
418
419static struct nft_object_type nft_limit_obj_type;
420static const struct nft_object_ops nft_limit_obj_bytes_ops = {
421 .type = &nft_limit_obj_type,
422 .size = sizeof(struct nft_limit_priv),
423 .init = nft_limit_obj_bytes_init,
424 .destroy = nft_limit_obj_bytes_destroy,
425 .eval = nft_limit_obj_bytes_eval,
426 .dump = nft_limit_obj_bytes_dump,
427};
428
429static const struct nft_object_ops *
430nft_limit_obj_select_ops(const struct nft_ctx *ctx,
431 const struct nlattr * const tb[])
432{
433 if (!tb[NFTA_LIMIT_TYPE])
434 return &nft_limit_obj_pkts_ops;
435
436 switch (ntohl(nla_get_be32(tb[NFTA_LIMIT_TYPE]))) {
437 case NFT_LIMIT_PKTS:
438 return &nft_limit_obj_pkts_ops;
439 case NFT_LIMIT_PKT_BYTES:
440 return &nft_limit_obj_bytes_ops;
441 }
442 return ERR_PTR(-EOPNOTSUPP);
443}
444
445static struct nft_object_type nft_limit_obj_type __read_mostly = {
446 .select_ops = nft_limit_obj_select_ops,
447 .type = NFT_OBJECT_LIMIT,
448 .maxattr = NFTA_LIMIT_MAX,
449 .policy = nft_limit_policy,
450 .owner = THIS_MODULE,
451};
452
453static int __init nft_limit_module_init(void)
454{
455 int err;
456
457 err = nft_register_obj(&nft_limit_obj_type);
458 if (err < 0)
459 return err;
460
461 err = nft_register_expr(&nft_limit_type);
462 if (err < 0)
463 goto err1;
464
465 return 0;
466err1:
467 nft_unregister_obj(&nft_limit_obj_type);
468 return err;
469}
470
471static void __exit nft_limit_module_exit(void)
472{
473 nft_unregister_expr(&nft_limit_type);
474 nft_unregister_obj(&nft_limit_obj_type);
475}
476
477module_init(nft_limit_module_init);
478module_exit(nft_limit_module_exit);
479
480MODULE_LICENSE("GPL");
481MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
482MODULE_ALIAS_NFT_EXPR("limit");
483MODULE_ALIAS_NFT_OBJ(NFT_OBJECT_LIMIT);
484MODULE_DESCRIPTION("nftables limit expression support");