1 /* 2 * net/sched/act_police.c Input police filter 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 * 9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 10 * J Hadi Salim (action changes) 11 */ 12 13 #include <linux/module.h> 14 #include <linux/types.h> 15 #include <linux/kernel.h> 16 #include <linux/string.h> 17 #include <linux/errno.h> 18 #include <linux/skbuff.h> 19 #include <linux/rtnetlink.h> 20 #include <linux/init.h> 21 #include <linux/slab.h> 22 #include <net/act_api.h> 23 #include <net/netlink.h> 24 #include <net/pkt_cls.h> 25 #include <net/tc_act/tc_police.h> 26 27 /* Each policer is serialized by its individual spinlock */ 28 29 static unsigned int police_net_id; 30 static struct tc_action_ops act_police_ops; 31 32 static int tcf_police_walker(struct net *net, struct sk_buff *skb, 33 struct netlink_callback *cb, int type, 34 const struct tc_action_ops *ops, 35 struct netlink_ext_ack *extack) 36 { 37 struct tc_action_net *tn = net_generic(net, police_net_id); 38 39 return tcf_generic_walker(tn, skb, cb, type, ops, extack); 40 } 41 42 static const struct nla_policy police_policy[TCA_POLICE_MAX + 1] = { 43 [TCA_POLICE_RATE] = { .len = TC_RTAB_SIZE }, 44 [TCA_POLICE_PEAKRATE] = { .len = TC_RTAB_SIZE }, 45 [TCA_POLICE_AVRATE] = { .type = NLA_U32 }, 46 [TCA_POLICE_RESULT] = { .type = NLA_U32 }, 47 }; 48 49 static int tcf_police_init(struct net *net, struct nlattr *nla, 50 struct nlattr *est, struct tc_action **a, 51 int ovr, int bind, bool rtnl_held, 52 struct tcf_proto *tp, 53 struct netlink_ext_ack *extack) 54 { 55 int ret = 0, tcfp_result = TC_ACT_OK, err, size; 56 struct nlattr *tb[TCA_POLICE_MAX + 1]; 57 struct tcf_chain *goto_ch = NULL; 58 struct tc_police *parm; 59 struct tcf_police *police; 60 struct qdisc_rate_table *R_tab = NULL, *P_tab = NULL; 61 struct tc_action_net *tn = net_generic(net, police_net_id); 62 struct tcf_police_params *new; 63 bool exists = false; 64 65 if (nla == NULL) 66 return -EINVAL; 67 68 err = nla_parse_nested_deprecated(tb, TCA_POLICE_MAX, nla, 69 police_policy, NULL); 70 if (err < 0) 71 return err; 72 73 if (tb[TCA_POLICE_TBF] == NULL) 74 return -EINVAL; 75 size = nla_len(tb[TCA_POLICE_TBF]); 76 if (size != sizeof(*parm) && size != sizeof(struct tc_police_compat)) 77 return -EINVAL; 78 79 parm = nla_data(tb[TCA_POLICE_TBF]); 80 err = tcf_idr_check_alloc(tn, &parm->index, a, bind); 81 if (err < 0) 82 return err; 83 exists = err; 84 if (exists && bind) 85 return 0; 86 87 if (!exists) { 88 ret = tcf_idr_create(tn, parm->index, NULL, a, 89 &act_police_ops, bind, true); 90 if (ret) { 91 tcf_idr_cleanup(tn, parm->index); 92 return ret; 93 } 94 ret = ACT_P_CREATED; 95 spin_lock_init(&(to_police(*a)->tcfp_lock)); 96 } else if (!ovr) { 97 tcf_idr_release(*a, bind); 98 return -EEXIST; 99 } 100 err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack); 101 if (err < 0) 102 goto release_idr; 103 104 police = to_police(*a); 105 if (parm->rate.rate) { 106 err = -ENOMEM; 107 R_tab = qdisc_get_rtab(&parm->rate, tb[TCA_POLICE_RATE], NULL); 108 if (R_tab == NULL) 109 goto failure; 110 111 if (parm->peakrate.rate) { 112 P_tab = qdisc_get_rtab(&parm->peakrate, 113 tb[TCA_POLICE_PEAKRATE], NULL); 114 if (P_tab == NULL) 115 goto failure; 116 } 117 } 118 119 if (est) { 120 err = gen_replace_estimator(&police->tcf_bstats, 121 police->common.cpu_bstats, 122 &police->tcf_rate_est, 123 &police->tcf_lock, 124 NULL, est); 125 if (err) 126 goto failure; 127 } else if (tb[TCA_POLICE_AVRATE] && 128 (ret == ACT_P_CREATED || 129 !gen_estimator_active(&police->tcf_rate_est))) { 130 err = -EINVAL; 131 goto failure; 132 } 133 134 if (tb[TCA_POLICE_RESULT]) { 135 tcfp_result = nla_get_u32(tb[TCA_POLICE_RESULT]); 136 if (TC_ACT_EXT_CMP(tcfp_result, TC_ACT_GOTO_CHAIN)) { 137 NL_SET_ERR_MSG(extack, 138 "goto chain not allowed on fallback"); 139 err = -EINVAL; 140 goto failure; 141 } 142 } 143 144 new = kzalloc(sizeof(*new), GFP_KERNEL); 145 if (unlikely(!new)) { 146 err = -ENOMEM; 147 goto failure; 148 } 149 150 /* No failure allowed after this point */ 151 new->tcfp_result = tcfp_result; 152 new->tcfp_mtu = parm->mtu; 153 if (!new->tcfp_mtu) { 154 new->tcfp_mtu = ~0; 155 if (R_tab) 156 new->tcfp_mtu = 255 << R_tab->rate.cell_log; 157 } 158 if (R_tab) { 159 new->rate_present = true; 160 psched_ratecfg_precompute(&new->rate, &R_tab->rate, 0); 161 qdisc_put_rtab(R_tab); 162 } else { 163 new->rate_present = false; 164 } 165 if (P_tab) { 166 new->peak_present = true; 167 psched_ratecfg_precompute(&new->peak, &P_tab->rate, 0); 168 qdisc_put_rtab(P_tab); 169 } else { 170 new->peak_present = false; 171 } 172 173 new->tcfp_burst = PSCHED_TICKS2NS(parm->burst); 174 if (new->peak_present) 175 new->tcfp_mtu_ptoks = (s64)psched_l2t_ns(&new->peak, 176 new->tcfp_mtu); 177 178 if (tb[TCA_POLICE_AVRATE]) 179 new->tcfp_ewma_rate = nla_get_u32(tb[TCA_POLICE_AVRATE]); 180 181 spin_lock_bh(&police->tcf_lock); 182 spin_lock_bh(&police->tcfp_lock); 183 police->tcfp_t_c = ktime_get_ns(); 184 police->tcfp_toks = new->tcfp_burst; 185 if (new->peak_present) 186 police->tcfp_ptoks = new->tcfp_mtu_ptoks; 187 spin_unlock_bh(&police->tcfp_lock); 188 goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch); 189 rcu_swap_protected(police->params, 190 new, 191 lockdep_is_held(&police->tcf_lock)); 192 spin_unlock_bh(&police->tcf_lock); 193 194 if (goto_ch) 195 tcf_chain_put_by_act(goto_ch); 196 if (new) 197 kfree_rcu(new, rcu); 198 199 if (ret == ACT_P_CREATED) 200 tcf_idr_insert(tn, *a); 201 return ret; 202 203 failure: 204 qdisc_put_rtab(P_tab); 205 qdisc_put_rtab(R_tab); 206 if (goto_ch) 207 tcf_chain_put_by_act(goto_ch); 208 release_idr: 209 tcf_idr_release(*a, bind); 210 return err; 211 } 212 213 static int tcf_police_act(struct sk_buff *skb, const struct tc_action *a, 214 struct tcf_result *res) 215 { 216 struct tcf_police *police = to_police(a); 217 struct tcf_police_params *p; 218 s64 now, toks, ptoks = 0; 219 int ret; 220 221 tcf_lastuse_update(&police->tcf_tm); 222 bstats_cpu_update(this_cpu_ptr(police->common.cpu_bstats), skb); 223 224 ret = READ_ONCE(police->tcf_action); 225 p = rcu_dereference_bh(police->params); 226 227 if (p->tcfp_ewma_rate) { 228 struct gnet_stats_rate_est64 sample; 229 230 if (!gen_estimator_read(&police->tcf_rate_est, &sample) || 231 sample.bps >= p->tcfp_ewma_rate) 232 goto inc_overlimits; 233 } 234 235 if (qdisc_pkt_len(skb) <= p->tcfp_mtu) { 236 if (!p->rate_present) { 237 ret = p->tcfp_result; 238 goto end; 239 } 240 241 now = ktime_get_ns(); 242 spin_lock_bh(&police->tcfp_lock); 243 toks = min_t(s64, now - police->tcfp_t_c, p->tcfp_burst); 244 if (p->peak_present) { 245 ptoks = toks + police->tcfp_ptoks; 246 if (ptoks > p->tcfp_mtu_ptoks) 247 ptoks = p->tcfp_mtu_ptoks; 248 ptoks -= (s64)psched_l2t_ns(&p->peak, 249 qdisc_pkt_len(skb)); 250 } 251 toks += police->tcfp_toks; 252 if (toks > p->tcfp_burst) 253 toks = p->tcfp_burst; 254 toks -= (s64)psched_l2t_ns(&p->rate, qdisc_pkt_len(skb)); 255 if ((toks|ptoks) >= 0) { 256 police->tcfp_t_c = now; 257 police->tcfp_toks = toks; 258 police->tcfp_ptoks = ptoks; 259 spin_unlock_bh(&police->tcfp_lock); 260 ret = p->tcfp_result; 261 goto inc_drops; 262 } 263 spin_unlock_bh(&police->tcfp_lock); 264 } 265 266 inc_overlimits: 267 qstats_overlimit_inc(this_cpu_ptr(police->common.cpu_qstats)); 268 inc_drops: 269 if (ret == TC_ACT_SHOT) 270 qstats_drop_inc(this_cpu_ptr(police->common.cpu_qstats)); 271 end: 272 return ret; 273 } 274 275 static void tcf_police_cleanup(struct tc_action *a) 276 { 277 struct tcf_police *police = to_police(a); 278 struct tcf_police_params *p; 279 280 p = rcu_dereference_protected(police->params, 1); 281 if (p) 282 kfree_rcu(p, rcu); 283 } 284 285 static void tcf_police_stats_update(struct tc_action *a, 286 u64 bytes, u32 packets, 287 u64 lastuse, bool hw) 288 { 289 struct tcf_police *police = to_police(a); 290 struct tcf_t *tm = &police->tcf_tm; 291 292 _bstats_cpu_update(this_cpu_ptr(a->cpu_bstats), bytes, packets); 293 if (hw) 294 _bstats_cpu_update(this_cpu_ptr(a->cpu_bstats_hw), 295 bytes, packets); 296 tm->lastuse = max_t(u64, tm->lastuse, lastuse); 297 } 298 299 static int tcf_police_dump(struct sk_buff *skb, struct tc_action *a, 300 int bind, int ref) 301 { 302 unsigned char *b = skb_tail_pointer(skb); 303 struct tcf_police *police = to_police(a); 304 struct tcf_police_params *p; 305 struct tc_police opt = { 306 .index = police->tcf_index, 307 .refcnt = refcount_read(&police->tcf_refcnt) - ref, 308 .bindcnt = atomic_read(&police->tcf_bindcnt) - bind, 309 }; 310 struct tcf_t t; 311 312 spin_lock_bh(&police->tcf_lock); 313 opt.action = police->tcf_action; 314 p = rcu_dereference_protected(police->params, 315 lockdep_is_held(&police->tcf_lock)); 316 opt.mtu = p->tcfp_mtu; 317 opt.burst = PSCHED_NS2TICKS(p->tcfp_burst); 318 if (p->rate_present) 319 psched_ratecfg_getrate(&opt.rate, &p->rate); 320 if (p->peak_present) 321 psched_ratecfg_getrate(&opt.peakrate, &p->peak); 322 if (nla_put(skb, TCA_POLICE_TBF, sizeof(opt), &opt)) 323 goto nla_put_failure; 324 if (p->tcfp_result && 325 nla_put_u32(skb, TCA_POLICE_RESULT, p->tcfp_result)) 326 goto nla_put_failure; 327 if (p->tcfp_ewma_rate && 328 nla_put_u32(skb, TCA_POLICE_AVRATE, p->tcfp_ewma_rate)) 329 goto nla_put_failure; 330 331 t.install = jiffies_to_clock_t(jiffies - police->tcf_tm.install); 332 t.lastuse = jiffies_to_clock_t(jiffies - police->tcf_tm.lastuse); 333 t.firstuse = jiffies_to_clock_t(jiffies - police->tcf_tm.firstuse); 334 t.expires = jiffies_to_clock_t(police->tcf_tm.expires); 335 if (nla_put_64bit(skb, TCA_POLICE_TM, sizeof(t), &t, TCA_POLICE_PAD)) 336 goto nla_put_failure; 337 spin_unlock_bh(&police->tcf_lock); 338 339 return skb->len; 340 341 nla_put_failure: 342 spin_unlock_bh(&police->tcf_lock); 343 nlmsg_trim(skb, b); 344 return -1; 345 } 346 347 static int tcf_police_search(struct net *net, struct tc_action **a, u32 index) 348 { 349 struct tc_action_net *tn = net_generic(net, police_net_id); 350 351 return tcf_idr_search(tn, a, index); 352 } 353 354 MODULE_AUTHOR("Alexey Kuznetsov"); 355 MODULE_DESCRIPTION("Policing actions"); 356 MODULE_LICENSE("GPL"); 357 358 static struct tc_action_ops act_police_ops = { 359 .kind = "police", 360 .id = TCA_ID_POLICE, 361 .owner = THIS_MODULE, 362 .stats_update = tcf_police_stats_update, 363 .act = tcf_police_act, 364 .dump = tcf_police_dump, 365 .init = tcf_police_init, 366 .walk = tcf_police_walker, 367 .lookup = tcf_police_search, 368 .cleanup = tcf_police_cleanup, 369 .size = sizeof(struct tcf_police), 370 }; 371 372 static __net_init int police_init_net(struct net *net) 373 { 374 struct tc_action_net *tn = net_generic(net, police_net_id); 375 376 return tc_action_net_init(tn, &act_police_ops); 377 } 378 379 static void __net_exit police_exit_net(struct list_head *net_list) 380 { 381 tc_action_net_exit(net_list, police_net_id); 382 } 383 384 static struct pernet_operations police_net_ops = { 385 .init = police_init_net, 386 .exit_batch = police_exit_net, 387 .id = &police_net_id, 388 .size = sizeof(struct tc_action_net), 389 }; 390 391 static int __init police_init_module(void) 392 { 393 return tcf_register_action(&act_police_ops, &police_net_ops); 394 } 395 396 static void __exit police_cleanup_module(void) 397 { 398 tcf_unregister_action(&act_police_ops, &police_net_ops); 399 } 400 401 module_init(police_init_module); 402 module_exit(police_cleanup_module); 403