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