~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/netfilter/nft_counter.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/seqlock.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 
 17 struct nft_counter {
 18         s64             bytes;
 19         s64             packets;
 20 };
 21 
 22 struct nft_counter_percpu_priv {
 23         struct nft_counter __percpu *counter;
 24 };
 25 
 26 static DEFINE_PER_CPU(seqcount_t, nft_counter_seq);
 27 
 28 static inline void nft_counter_do_eval(struct nft_counter_percpu_priv *priv,
 29                                        struct nft_regs *regs,
 30                                        const struct nft_pktinfo *pkt)
 31 {
 32         struct nft_counter *this_cpu;
 33         seqcount_t *myseq;
 34 
 35         local_bh_disable();
 36         this_cpu = this_cpu_ptr(priv->counter);
 37         myseq = this_cpu_ptr(&nft_counter_seq);
 38 
 39         write_seqcount_begin(myseq);
 40 
 41         this_cpu->bytes += pkt->skb->len;
 42         this_cpu->packets++;
 43 
 44         write_seqcount_end(myseq);
 45         local_bh_enable();
 46 }
 47 
 48 static inline void nft_counter_obj_eval(struct nft_object *obj,
 49                                         struct nft_regs *regs,
 50                                         const struct nft_pktinfo *pkt)
 51 {
 52         struct nft_counter_percpu_priv *priv = nft_obj_data(obj);
 53 
 54         nft_counter_do_eval(priv, regs, pkt);
 55 }
 56 
 57 static int nft_counter_do_init(const struct nlattr * const tb[],
 58                                struct nft_counter_percpu_priv *priv)
 59 {
 60         struct nft_counter __percpu *cpu_stats;
 61         struct nft_counter *this_cpu;
 62 
 63         cpu_stats = alloc_percpu(struct nft_counter);
 64         if (cpu_stats == NULL)
 65                 return -ENOMEM;
 66 
 67         preempt_disable();
 68         this_cpu = this_cpu_ptr(cpu_stats);
 69         if (tb[NFTA_COUNTER_PACKETS]) {
 70                 this_cpu->packets =
 71                         be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_PACKETS]));
 72         }
 73         if (tb[NFTA_COUNTER_BYTES]) {
 74                 this_cpu->bytes =
 75                         be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_BYTES]));
 76         }
 77         preempt_enable();
 78         priv->counter = cpu_stats;
 79         return 0;
 80 }
 81 
 82 static int nft_counter_obj_init(const struct nft_ctx *ctx,
 83                                 const struct nlattr * const tb[],
 84                                 struct nft_object *obj)
 85 {
 86         struct nft_counter_percpu_priv *priv = nft_obj_data(obj);
 87 
 88         return nft_counter_do_init(tb, priv);
 89 }
 90 
 91 static void nft_counter_do_destroy(struct nft_counter_percpu_priv *priv)
 92 {
 93         free_percpu(priv->counter);
 94 }
 95 
 96 static void nft_counter_obj_destroy(const struct nft_ctx *ctx,
 97                                     struct nft_object *obj)
 98 {
 99         struct nft_counter_percpu_priv *priv = nft_obj_data(obj);
100 
101         nft_counter_do_destroy(priv);
102 }
103 
104 static void nft_counter_reset(struct nft_counter_percpu_priv *priv,
105                               struct nft_counter *total)
106 {
107         struct nft_counter *this_cpu;
108 
109         local_bh_disable();
110         this_cpu = this_cpu_ptr(priv->counter);
111         this_cpu->packets -= total->packets;
112         this_cpu->bytes -= total->bytes;
113         local_bh_enable();
114 }
115 
116 static void nft_counter_fetch(struct nft_counter_percpu_priv *priv,
117                               struct nft_counter *total)
118 {
119         struct nft_counter *this_cpu;
120         const seqcount_t *myseq;
121         u64 bytes, packets;
122         unsigned int seq;
123         int cpu;
124 
125         memset(total, 0, sizeof(*total));
126         for_each_possible_cpu(cpu) {
127                 myseq = per_cpu_ptr(&nft_counter_seq, cpu);
128                 this_cpu = per_cpu_ptr(priv->counter, cpu);
129                 do {
130                         seq     = read_seqcount_begin(myseq);
131                         bytes   = this_cpu->bytes;
132                         packets = this_cpu->packets;
133                 } while (read_seqcount_retry(myseq, seq));
134 
135                 total->bytes    += bytes;
136                 total->packets  += packets;
137         }
138 }
139 
140 static int nft_counter_do_dump(struct sk_buff *skb,
141                                struct nft_counter_percpu_priv *priv,
142                                bool reset)
143 {
144         struct nft_counter total;
145 
146         nft_counter_fetch(priv, &total);
147 
148         if (nla_put_be64(skb, NFTA_COUNTER_BYTES, cpu_to_be64(total.bytes),
149                          NFTA_COUNTER_PAD) ||
150             nla_put_be64(skb, NFTA_COUNTER_PACKETS, cpu_to_be64(total.packets),
151                          NFTA_COUNTER_PAD))
152                 goto nla_put_failure;
153 
154         if (reset)
155                 nft_counter_reset(priv, &total);
156 
157         return 0;
158 
159 nla_put_failure:
160         return -1;
161 }
162 
163 static int nft_counter_obj_dump(struct sk_buff *skb,
164                                 struct nft_object *obj, bool reset)
165 {
166         struct nft_counter_percpu_priv *priv = nft_obj_data(obj);
167 
168         return nft_counter_do_dump(skb, priv, reset);
169 }
170 
171 static const struct nla_policy nft_counter_policy[NFTA_COUNTER_MAX + 1] = {
172         [NFTA_COUNTER_PACKETS]  = { .type = NLA_U64 },
173         [NFTA_COUNTER_BYTES]    = { .type = NLA_U64 },
174 };
175 
176 static struct nft_object_type nft_counter_obj_type;
177 static const struct nft_object_ops nft_counter_obj_ops = {
178         .type           = &nft_counter_obj_type,
179         .size           = sizeof(struct nft_counter_percpu_priv),
180         .eval           = nft_counter_obj_eval,
181         .init           = nft_counter_obj_init,
182         .destroy        = nft_counter_obj_destroy,
183         .dump           = nft_counter_obj_dump,
184 };
185 
186 static struct nft_object_type nft_counter_obj_type __read_mostly = {
187         .type           = NFT_OBJECT_COUNTER,
188         .ops            = &nft_counter_obj_ops,
189         .maxattr        = NFTA_COUNTER_MAX,
190         .policy         = nft_counter_policy,
191         .owner          = THIS_MODULE,
192 };
193 
194 static void nft_counter_eval(const struct nft_expr *expr,
195                              struct nft_regs *regs,
196                              const struct nft_pktinfo *pkt)
197 {
198         struct nft_counter_percpu_priv *priv = nft_expr_priv(expr);
199 
200         nft_counter_do_eval(priv, regs, pkt);
201 }
202 
203 static int nft_counter_dump(struct sk_buff *skb, const struct nft_expr *expr)
204 {
205         struct nft_counter_percpu_priv *priv = nft_expr_priv(expr);
206 
207         return nft_counter_do_dump(skb, priv, false);
208 }
209 
210 static int nft_counter_init(const struct nft_ctx *ctx,
211                             const struct nft_expr *expr,
212                             const struct nlattr * const tb[])
213 {
214         struct nft_counter_percpu_priv *priv = nft_expr_priv(expr);
215 
216         return nft_counter_do_init(tb, priv);
217 }
218 
219 static void nft_counter_destroy(const struct nft_ctx *ctx,
220                                 const struct nft_expr *expr)
221 {
222         struct nft_counter_percpu_priv *priv = nft_expr_priv(expr);
223 
224         nft_counter_do_destroy(priv);
225 }
226 
227 static int nft_counter_clone(struct nft_expr *dst, const struct nft_expr *src)
228 {
229         struct nft_counter_percpu_priv *priv = nft_expr_priv(src);
230         struct nft_counter_percpu_priv *priv_clone = nft_expr_priv(dst);
231         struct nft_counter __percpu *cpu_stats;
232         struct nft_counter *this_cpu;
233         struct nft_counter total;
234 
235         nft_counter_fetch(priv, &total);
236 
237         cpu_stats = alloc_percpu_gfp(struct nft_counter, GFP_ATOMIC);
238         if (cpu_stats == NULL)
239                 return -ENOMEM;
240 
241         preempt_disable();
242         this_cpu = this_cpu_ptr(cpu_stats);
243         this_cpu->packets = total.packets;
244         this_cpu->bytes = total.bytes;
245         preempt_enable();
246 
247         priv_clone->counter = cpu_stats;
248         return 0;
249 }
250 
251 static struct nft_expr_type nft_counter_type;
252 static const struct nft_expr_ops nft_counter_ops = {
253         .type           = &nft_counter_type,
254         .size           = NFT_EXPR_SIZE(sizeof(struct nft_counter_percpu_priv)),
255         .eval           = nft_counter_eval,
256         .init           = nft_counter_init,
257         .destroy        = nft_counter_destroy,
258         .destroy_clone  = nft_counter_destroy,
259         .dump           = nft_counter_dump,
260         .clone          = nft_counter_clone,
261 };
262 
263 static struct nft_expr_type nft_counter_type __read_mostly = {
264         .name           = "counter",
265         .ops            = &nft_counter_ops,
266         .policy         = nft_counter_policy,
267         .maxattr        = NFTA_COUNTER_MAX,
268         .flags          = NFT_EXPR_STATEFUL,
269         .owner          = THIS_MODULE,
270 };
271 
272 static int __init nft_counter_module_init(void)
273 {
274         int cpu, err;
275 
276         for_each_possible_cpu(cpu)
277                 seqcount_init(per_cpu_ptr(&nft_counter_seq, cpu));
278 
279         err = nft_register_obj(&nft_counter_obj_type);
280         if (err < 0)
281                 return err;
282 
283         err = nft_register_expr(&nft_counter_type);
284         if (err < 0)
285                 goto err1;
286 
287         return 0;
288 err1:
289         nft_unregister_obj(&nft_counter_obj_type);
290         return err;
291 }
292 
293 static void __exit nft_counter_module_exit(void)
294 {
295         nft_unregister_expr(&nft_counter_type);
296         nft_unregister_obj(&nft_counter_obj_type);
297 }
298 
299 module_init(nft_counter_module_init);
300 module_exit(nft_counter_module_exit);
301 
302 MODULE_LICENSE("GPL");
303 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
304 MODULE_ALIAS_NFT_EXPR("counter");
305 MODULE_ALIAS_NFT_OBJ(NFT_OBJECT_COUNTER);
306 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp