]>
Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
91dbc6be LGL |
2 | /* |
3 | * Copyright (c) 2016 Laura Garcia <nevola@gmail.com> | |
91dbc6be LGL |
4 | */ |
5 | ||
6 | #include <linux/kernel.h> | |
7 | #include <linux/init.h> | |
8 | #include <linux/module.h> | |
9 | #include <linux/netlink.h> | |
10 | #include <linux/netfilter.h> | |
11 | #include <linux/netfilter/nf_tables.h> | |
12 | #include <linux/static_key.h> | |
13 | #include <net/netfilter/nf_tables.h> | |
14 | #include <net/netfilter/nf_tables_core.h> | |
15 | ||
16 | static DEFINE_PER_CPU(struct rnd_state, nft_numgen_prandom_state); | |
17 | ||
18 | struct nft_ng_inc { | |
345023b0 | 19 | u8 dreg; |
0d9932b2 | 20 | u32 modulus; |
91dbc6be | 21 | atomic_t counter; |
2b03bf73 | 22 | u32 offset; |
91dbc6be LGL |
23 | }; |
24 | ||
d734a288 | 25 | static u32 nft_ng_inc_gen(struct nft_ng_inc *priv) |
91dbc6be | 26 | { |
91dbc6be LGL |
27 | u32 nval, oval; |
28 | ||
29 | do { | |
30 | oval = atomic_read(&priv->counter); | |
0d9932b2 | 31 | nval = (oval + 1 < priv->modulus) ? oval + 1 : 0; |
91dbc6be LGL |
32 | } while (atomic_cmpxchg(&priv->counter, oval, nval) != oval); |
33 | ||
d734a288 LGL |
34 | return nval + priv->offset; |
35 | } | |
36 | ||
37 | static void nft_ng_inc_eval(const struct nft_expr *expr, | |
38 | struct nft_regs *regs, | |
39 | const struct nft_pktinfo *pkt) | |
40 | { | |
41 | struct nft_ng_inc *priv = nft_expr_priv(expr); | |
42 | ||
43 | regs->data[priv->dreg] = nft_ng_inc_gen(priv); | |
44 | } | |
45 | ||
91dbc6be LGL |
46 | static const struct nla_policy nft_ng_policy[NFTA_NG_MAX + 1] = { |
47 | [NFTA_NG_DREG] = { .type = NLA_U32 }, | |
0d9932b2 | 48 | [NFTA_NG_MODULUS] = { .type = NLA_U32 }, |
91dbc6be | 49 | [NFTA_NG_TYPE] = { .type = NLA_U32 }, |
2b03bf73 | 50 | [NFTA_NG_OFFSET] = { .type = NLA_U32 }, |
91dbc6be LGL |
51 | }; |
52 | ||
53 | static int nft_ng_inc_init(const struct nft_ctx *ctx, | |
54 | const struct nft_expr *expr, | |
55 | const struct nlattr * const tb[]) | |
56 | { | |
57 | struct nft_ng_inc *priv = nft_expr_priv(expr); | |
58 | ||
2b03bf73 LGL |
59 | if (tb[NFTA_NG_OFFSET]) |
60 | priv->offset = ntohl(nla_get_be32(tb[NFTA_NG_OFFSET])); | |
61 | ||
0d9932b2 LGL |
62 | priv->modulus = ntohl(nla_get_be32(tb[NFTA_NG_MODULUS])); |
63 | if (priv->modulus == 0) | |
91dbc6be LGL |
64 | return -ERANGE; |
65 | ||
2b03bf73 LGL |
66 | if (priv->offset + priv->modulus - 1 < priv->offset) |
67 | return -EOVERFLOW; | |
68 | ||
0ecba4d9 | 69 | atomic_set(&priv->counter, priv->modulus - 1); |
91dbc6be | 70 | |
345023b0 PNA |
71 | return nft_parse_register_store(ctx, tb[NFTA_NG_DREG], &priv->dreg, |
72 | NULL, NFT_DATA_VALUE, sizeof(u32)); | |
91dbc6be LGL |
73 | } |
74 | ||
75 | static int nft_ng_dump(struct sk_buff *skb, enum nft_registers dreg, | |
2b03bf73 | 76 | u32 modulus, enum nft_ng_types type, u32 offset) |
91dbc6be LGL |
77 | { |
78 | if (nft_dump_register(skb, NFTA_NG_DREG, dreg)) | |
79 | goto nla_put_failure; | |
0d9932b2 | 80 | if (nla_put_be32(skb, NFTA_NG_MODULUS, htonl(modulus))) |
91dbc6be | 81 | goto nla_put_failure; |
7073b16f | 82 | if (nla_put_be32(skb, NFTA_NG_TYPE, htonl(type))) |
91dbc6be | 83 | goto nla_put_failure; |
2b03bf73 LGL |
84 | if (nla_put_be32(skb, NFTA_NG_OFFSET, htonl(offset))) |
85 | goto nla_put_failure; | |
91dbc6be LGL |
86 | |
87 | return 0; | |
88 | ||
89 | nla_put_failure: | |
90 | return -1; | |
91 | } | |
92 | ||
93 | static int nft_ng_inc_dump(struct sk_buff *skb, const struct nft_expr *expr) | |
94 | { | |
95 | const struct nft_ng_inc *priv = nft_expr_priv(expr); | |
96 | ||
2b03bf73 LGL |
97 | return nft_ng_dump(skb, priv->dreg, priv->modulus, NFT_NG_INCREMENTAL, |
98 | priv->offset); | |
91dbc6be LGL |
99 | } |
100 | ||
101 | struct nft_ng_random { | |
345023b0 | 102 | u8 dreg; |
0d9932b2 | 103 | u32 modulus; |
2b03bf73 | 104 | u32 offset; |
91dbc6be LGL |
105 | }; |
106 | ||
978d8f90 LGL |
107 | static u32 nft_ng_random_gen(struct nft_ng_random *priv) |
108 | { | |
109 | struct rnd_state *state = this_cpu_ptr(&nft_numgen_prandom_state); | |
110 | ||
111 | return reciprocal_scale(prandom_u32_state(state), priv->modulus) + | |
112 | priv->offset; | |
113 | } | |
114 | ||
91dbc6be LGL |
115 | static void nft_ng_random_eval(const struct nft_expr *expr, |
116 | struct nft_regs *regs, | |
117 | const struct nft_pktinfo *pkt) | |
118 | { | |
119 | struct nft_ng_random *priv = nft_expr_priv(expr); | |
91dbc6be | 120 | |
978d8f90 LGL |
121 | regs->data[priv->dreg] = nft_ng_random_gen(priv); |
122 | } | |
123 | ||
91dbc6be LGL |
124 | static int nft_ng_random_init(const struct nft_ctx *ctx, |
125 | const struct nft_expr *expr, | |
126 | const struct nlattr * const tb[]) | |
127 | { | |
128 | struct nft_ng_random *priv = nft_expr_priv(expr); | |
129 | ||
2b03bf73 LGL |
130 | if (tb[NFTA_NG_OFFSET]) |
131 | priv->offset = ntohl(nla_get_be32(tb[NFTA_NG_OFFSET])); | |
132 | ||
0d9932b2 LGL |
133 | priv->modulus = ntohl(nla_get_be32(tb[NFTA_NG_MODULUS])); |
134 | if (priv->modulus == 0) | |
91dbc6be LGL |
135 | return -ERANGE; |
136 | ||
2b03bf73 LGL |
137 | if (priv->offset + priv->modulus - 1 < priv->offset) |
138 | return -EOVERFLOW; | |
139 | ||
91dbc6be LGL |
140 | prandom_init_once(&nft_numgen_prandom_state); |
141 | ||
345023b0 PNA |
142 | return nft_parse_register_store(ctx, tb[NFTA_NG_DREG], &priv->dreg, |
143 | NULL, NFT_DATA_VALUE, sizeof(u32)); | |
91dbc6be LGL |
144 | } |
145 | ||
146 | static int nft_ng_random_dump(struct sk_buff *skb, const struct nft_expr *expr) | |
147 | { | |
148 | const struct nft_ng_random *priv = nft_expr_priv(expr); | |
149 | ||
2b03bf73 LGL |
150 | return nft_ng_dump(skb, priv->dreg, priv->modulus, NFT_NG_RANDOM, |
151 | priv->offset); | |
91dbc6be LGL |
152 | } |
153 | ||
154 | static struct nft_expr_type nft_ng_type; | |
155 | static const struct nft_expr_ops nft_ng_inc_ops = { | |
156 | .type = &nft_ng_type, | |
157 | .size = NFT_EXPR_SIZE(sizeof(struct nft_ng_inc)), | |
158 | .eval = nft_ng_inc_eval, | |
159 | .init = nft_ng_inc_init, | |
160 | .dump = nft_ng_inc_dump, | |
161 | }; | |
162 | ||
163 | static const struct nft_expr_ops nft_ng_random_ops = { | |
164 | .type = &nft_ng_type, | |
165 | .size = NFT_EXPR_SIZE(sizeof(struct nft_ng_random)), | |
166 | .eval = nft_ng_random_eval, | |
167 | .init = nft_ng_random_init, | |
168 | .dump = nft_ng_random_dump, | |
169 | }; | |
170 | ||
171 | static const struct nft_expr_ops * | |
172 | nft_ng_select_ops(const struct nft_ctx *ctx, const struct nlattr * const tb[]) | |
173 | { | |
174 | u32 type; | |
175 | ||
0d9932b2 LGL |
176 | if (!tb[NFTA_NG_DREG] || |
177 | !tb[NFTA_NG_MODULUS] || | |
91dbc6be LGL |
178 | !tb[NFTA_NG_TYPE]) |
179 | return ERR_PTR(-EINVAL); | |
180 | ||
181 | type = ntohl(nla_get_be32(tb[NFTA_NG_TYPE])); | |
182 | ||
183 | switch (type) { | |
184 | case NFT_NG_INCREMENTAL: | |
185 | return &nft_ng_inc_ops; | |
186 | case NFT_NG_RANDOM: | |
187 | return &nft_ng_random_ops; | |
188 | } | |
189 | ||
190 | return ERR_PTR(-EINVAL); | |
191 | } | |
192 | ||
193 | static struct nft_expr_type nft_ng_type __read_mostly = { | |
194 | .name = "numgen", | |
d4ef3835 | 195 | .select_ops = nft_ng_select_ops, |
91dbc6be LGL |
196 | .policy = nft_ng_policy, |
197 | .maxattr = NFTA_NG_MAX, | |
198 | .owner = THIS_MODULE, | |
199 | }; | |
200 | ||
201 | static int __init nft_ng_module_init(void) | |
202 | { | |
203 | return nft_register_expr(&nft_ng_type); | |
204 | } | |
205 | ||
206 | static void __exit nft_ng_module_exit(void) | |
207 | { | |
208 | nft_unregister_expr(&nft_ng_type); | |
209 | } | |
210 | ||
211 | module_init(nft_ng_module_init); | |
212 | module_exit(nft_ng_module_exit); | |
213 | ||
214 | MODULE_LICENSE("GPL"); | |
215 | MODULE_AUTHOR("Laura Garcia <nevola@gmail.com>"); | |
216 | MODULE_ALIAS_NFT_EXPR("numgen"); | |
4cacc395 | 217 | MODULE_DESCRIPTION("nftables number generator module"); |