1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * net/sched/act_police.c Input police filter 4 * 5 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 6 * J Hadi Salim (action changes) 7 */ 8 9 #include <linux/module.h> 10 #include <linux/types.h> 11 #include <linux/kernel.h> 12 #include <linux/string.h> 13 #include <linux/errno.h> 14 #include <linux/skbuff.h> 15 #include <linux/rtnetlink.h> 16 #include <linux/init.h> 17 #include <linux/slab.h> 18 #include <net/act_api.h> 19 #include <net/gso.h> 20 #include <net/netlink.h> 21 #include <net/pkt_cls.h> 22 #include <net/tc_act/tc_police.h> 23 #include <net/tc_wrapper.h> 24 25 /* Each policer is serialized by its individual spinlock */ 26 27 static struct tc_action_ops act_police_ops; 28 29 static const struct nla_policy police_policy[TCA_POLICE_MAX + 1] = { 30 [TCA_POLICE_RATE] = { .len = TC_RTAB_SIZE }, 31 [TCA_POLICE_PEAKRATE] = { .len = TC_RTAB_SIZE }, 32 [TCA_POLICE_AVRATE] = { .type = NLA_U32 }, 33 [TCA_POLICE_RESULT] = { .type = NLA_U32 }, 34 [TCA_POLICE_RATE64] = { .type = NLA_U64 }, 35 [TCA_POLICE_PEAKRATE64] = { .type = NLA_U64 }, 36 [TCA_POLICE_PKTRATE64] = { .type = NLA_U64, .min = 1 }, 37 [TCA_POLICE_PKTBURST64] = { .type = NLA_U64, .min = 1 }, 38 }; 39 40 static int tcf_police_init(struct net *net, struct nlattr *nla, 41 struct nlattr *est, struct tc_action **a, 42 struct tcf_proto *tp, u32 flags, 43 struct netlink_ext_ack *extack) 44 { 45 int ret = 0, tcfp_result = TC_ACT_OK, err, size; 46 bool bind = flags & TCA_ACT_FLAGS_BIND; 47 struct nlattr *tb[TCA_POLICE_MAX + 1]; 48 struct tcf_chain *goto_ch = NULL; 49 struct tc_police *parm; 50 struct tcf_police *police; 51 struct qdisc_rate_table *R_tab = NULL, *P_tab = NULL; 52 struct tc_action_net *tn = net_generic(net, act_police_ops.net_id); 53 struct tcf_police_params *new; 54 bool exists = false; 55 u32 index; 56 u64 rate64, prate64; 57 u64 pps, ppsburst; 58 59 if (nla == NULL) 60 return -EINVAL; 61 62 err = nla_parse_nested_deprecated(tb, TCA_POLICE_MAX, nla, 63 police_policy, NULL); 64 if (err < 0) 65 return err; 66 67 if (tb[TCA_POLICE_TBF] == NULL) 68 return -EINVAL; 69 size = nla_len(tb[TCA_POLICE_TBF]); 70 if (size != sizeof(*parm) && size != sizeof(struct tc_police_compat)) 71 return -EINVAL; 72 73 parm = nla_data(tb[TCA_POLICE_TBF]); 74 index = parm->index; 75 err = tcf_idr_check_alloc(tn, &index, a, bind); 76 if (err < 0) 77 return err; 78 exists = err; 79 if (exists && bind) 80 return ACT_P_BOUND; 81 82 if (!exists) { 83 ret = tcf_idr_create(tn, index, NULL, a, 84 &act_police_ops, bind, true, flags); 85 if (ret) { 86 tcf_idr_cleanup(tn, index); 87 return ret; 88 } 89 ret = ACT_P_CREATED; 90 spin_lock_init(&(to_police(*a)->tcfp_lock)); 91 } else if (!(flags & TCA_ACT_FLAGS_REPLACE)) { 92 tcf_idr_release(*a, bind); 93 return -EEXIST; 94 } 95 err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack); 96 if (err < 0) 97 goto release_idr; 98 99 police = to_police(*a); 100 if (parm->rate.rate) { 101 err = -ENOMEM; 102 R_tab = qdisc_get_rtab(&parm->rate, tb[TCA_POLICE_RATE], NULL); 103 if (R_tab == NULL) 104 goto failure; 105 106 if (parm->peakrate.rate) { 107 P_tab = qdisc_get_rtab(&parm->peakrate, 108 tb[TCA_POLICE_PEAKRATE], NULL); 109 if (P_tab == NULL) 110 goto failure; 111 } 112 } 113 114 if (est) { 115 err = gen_replace_estimator(&police->tcf_bstats, 116 police->common.cpu_bstats, 117 &police->tcf_rate_est, 118 &police->tcf_lock, 119 false, est); 120 if (err) 121 goto failure; 122 } else if (tb[TCA_POLICE_AVRATE] && 123 (ret == ACT_P_CREATED || 124 !gen_estimator_active(&police->tcf_rate_est))) { 125 err = -EINVAL; 126 goto failure; 127 } 128 129 if (tb[TCA_POLICE_RESULT]) { 130 tcfp_result = nla_get_u32(tb[TCA_POLICE_RESULT]); 131 if (!tcf_action_valid(tcfp_result)) { 132 NL_SET_ERR_MSG(extack, 133 "invalid fallback control action"); 134 err = -EINVAL; 135 goto failure; 136 } 137 if (TC_ACT_EXT_CMP(tcfp_result, TC_ACT_GOTO_CHAIN)) { 138 NL_SET_ERR_MSG(extack, 139 "goto chain not allowed on fallback"); 140 err = -EINVAL; 141 goto failure; 142 } 143 } 144 145 if ((tb[TCA_POLICE_PKTRATE64] && !tb[TCA_POLICE_PKTBURST64]) || 146 (!tb[TCA_POLICE_PKTRATE64] && tb[TCA_POLICE_PKTBURST64])) { 147 NL_SET_ERR_MSG(extack, 148 "Both or neither packet-per-second burst and rate must be provided"); 149 err = -EINVAL; 150 goto failure; 151 } 152 153 if (tb[TCA_POLICE_PKTRATE64] && R_tab) { 154 NL_SET_ERR_MSG(extack, 155 "packet-per-second and byte-per-second rate limits not allowed in same action"); 156 err = -EINVAL; 157 goto failure; 158 } 159 160 new = kzalloc_obj(*new); 161 if (unlikely(!new)) { 162 err = -ENOMEM; 163 goto failure; 164 } 165 166 /* No failure allowed after this point */ 167 new->tcfp_result = tcfp_result; 168 new->tcfp_mtu = parm->mtu; 169 if (!new->tcfp_mtu) { 170 new->tcfp_mtu = ~0; 171 if (R_tab) 172 new->tcfp_mtu = 255 << R_tab->rate.cell_log; 173 } 174 if (R_tab) { 175 new->rate_present = true; 176 rate64 = nla_get_u64_default(tb[TCA_POLICE_RATE64], 0); 177 psched_ratecfg_precompute(&new->rate, &R_tab->rate, rate64); 178 qdisc_put_rtab(R_tab); 179 } else { 180 new->rate_present = false; 181 } 182 if (P_tab) { 183 new->peak_present = true; 184 prate64 = nla_get_u64_default(tb[TCA_POLICE_PEAKRATE64], 0); 185 psched_ratecfg_precompute(&new->peak, &P_tab->rate, prate64); 186 qdisc_put_rtab(P_tab); 187 } else { 188 new->peak_present = false; 189 } 190 191 new->tcfp_burst = PSCHED_TICKS2NS(parm->burst); 192 if (new->peak_present) 193 new->tcfp_mtu_ptoks = (s64)psched_l2t_ns(&new->peak, 194 new->tcfp_mtu); 195 196 if (tb[TCA_POLICE_AVRATE]) 197 new->tcfp_ewma_rate = nla_get_u32(tb[TCA_POLICE_AVRATE]); 198 199 if (tb[TCA_POLICE_PKTRATE64]) { 200 pps = nla_get_u64(tb[TCA_POLICE_PKTRATE64]); 201 ppsburst = nla_get_u64(tb[TCA_POLICE_PKTBURST64]); 202 new->pps_present = true; 203 new->tcfp_pkt_burst = PSCHED_TICKS2NS(ppsburst); 204 psched_ppscfg_precompute(&new->ppsrate, pps); 205 } 206 207 new->action = parm->action; 208 spin_lock_bh(&police->tcf_lock); 209 spin_lock_bh(&police->tcfp_lock); 210 police->tcfp_t_c = ktime_get_ns(); 211 police->tcfp_toks = new->tcfp_burst; 212 if (new->peak_present) 213 police->tcfp_ptoks = new->tcfp_mtu_ptoks; 214 spin_unlock_bh(&police->tcfp_lock); 215 goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch); 216 new = rcu_replace_pointer(police->params, 217 new, 218 lockdep_is_held(&police->tcf_lock)); 219 spin_unlock_bh(&police->tcf_lock); 220 221 if (goto_ch) 222 tcf_chain_put_by_act(goto_ch); 223 if (new) 224 kfree_rcu(new, rcu); 225 226 return ret; 227 228 failure: 229 qdisc_put_rtab(P_tab); 230 qdisc_put_rtab(R_tab); 231 if (goto_ch) 232 tcf_chain_put_by_act(goto_ch); 233 release_idr: 234 tcf_idr_release(*a, bind); 235 return err; 236 } 237 238 static bool tcf_police_mtu_check(struct sk_buff *skb, u32 limit) 239 { 240 u32 len; 241 242 if (skb_is_gso(skb)) 243 return skb_gso_validate_mac_len(skb, limit); 244 245 len = qdisc_pkt_len(skb); 246 if (skb_at_tc_ingress(skb)) 247 len += skb->mac_len; 248 249 return len <= limit; 250 } 251 252 TC_INDIRECT_SCOPE int tcf_police_act(struct sk_buff *skb, 253 const struct tc_action *a, 254 struct tcf_result *res) 255 { 256 struct tcf_police *police = to_police(a); 257 s64 now, toks, ppstoks = 0, ptoks = 0; 258 struct tcf_police_params *p; 259 int ret; 260 261 tcf_lastuse_update(&police->tcf_tm); 262 bstats_update(this_cpu_ptr(police->common.cpu_bstats), skb); 263 264 p = rcu_dereference_bh(police->params); 265 ret = p->action; 266 267 if (p->tcfp_ewma_rate) { 268 struct gnet_stats_rate_est64 sample; 269 270 if (!gen_estimator_read(&police->tcf_rate_est, &sample) || 271 sample.bps >= p->tcfp_ewma_rate) 272 goto inc_overlimits; 273 } 274 275 if (tcf_police_mtu_check(skb, p->tcfp_mtu)) { 276 if (!p->rate_present && !p->pps_present) { 277 ret = p->tcfp_result; 278 goto end; 279 } 280 281 now = ktime_get_ns(); 282 spin_lock_bh(&police->tcfp_lock); 283 toks = min_t(s64, now - police->tcfp_t_c, p->tcfp_burst); 284 if (p->peak_present) { 285 ptoks = toks + police->tcfp_ptoks; 286 if (ptoks > p->tcfp_mtu_ptoks) 287 ptoks = p->tcfp_mtu_ptoks; 288 ptoks -= (s64)psched_l2t_ns(&p->peak, 289 qdisc_pkt_len(skb)); 290 } 291 if (p->rate_present) { 292 toks += police->tcfp_toks; 293 if (toks > p->tcfp_burst) 294 toks = p->tcfp_burst; 295 toks -= (s64)psched_l2t_ns(&p->rate, qdisc_pkt_len(skb)); 296 } else if (p->pps_present) { 297 ppstoks = min_t(s64, now - police->tcfp_t_c, p->tcfp_pkt_burst); 298 ppstoks += police->tcfp_pkttoks; 299 if (ppstoks > p->tcfp_pkt_burst) 300 ppstoks = p->tcfp_pkt_burst; 301 ppstoks -= (s64)psched_pkt2t_ns(&p->ppsrate, 1); 302 } 303 if ((toks | ptoks | ppstoks) >= 0) { 304 police->tcfp_t_c = now; 305 police->tcfp_toks = toks; 306 police->tcfp_ptoks = ptoks; 307 police->tcfp_pkttoks = ppstoks; 308 spin_unlock_bh(&police->tcfp_lock); 309 ret = p->tcfp_result; 310 goto inc_drops; 311 } 312 spin_unlock_bh(&police->tcfp_lock); 313 } 314 315 inc_overlimits: 316 qstats_cpu_overlimit_inc(police->common.cpu_qstats); 317 inc_drops: 318 if (ret == TC_ACT_SHOT) 319 qstats_cpu_drop_inc(police->common.cpu_qstats); 320 end: 321 return ret; 322 } 323 324 static void tcf_police_cleanup(struct tc_action *a) 325 { 326 struct tcf_police *police = to_police(a); 327 struct tcf_police_params *p; 328 329 p = rcu_dereference_protected(police->params, 1); 330 if (p) 331 kfree_rcu(p, rcu); 332 } 333 334 static void tcf_police_stats_update(struct tc_action *a, 335 u64 bytes, u64 packets, u64 drops, 336 u64 lastuse, bool hw) 337 { 338 struct tcf_police *police = to_police(a); 339 struct tcf_t *tm = &police->tcf_tm; 340 341 tcf_action_update_stats(a, bytes, packets, drops, hw); 342 tm->lastuse = max_t(u64, tm->lastuse, lastuse); 343 } 344 345 static int tcf_police_dump(struct sk_buff *skb, struct tc_action *a, 346 int bind, int ref) 347 { 348 const struct tcf_police *police = to_police(a); 349 unsigned char *b = skb_tail_pointer(skb); 350 const struct tcf_police_params *p; 351 struct tc_police opt = { 352 .index = police->tcf_index, 353 .refcnt = refcount_read(&police->tcf_refcnt) - ref, 354 .bindcnt = atomic_read(&police->tcf_bindcnt) - bind, 355 }; 356 struct tcf_t t; 357 358 rcu_read_lock(); 359 p = rcu_dereference(police->params); 360 opt.action = p->action; 361 opt.mtu = p->tcfp_mtu; 362 opt.burst = PSCHED_NS2TICKS(p->tcfp_burst); 363 if (p->rate_present) { 364 psched_ratecfg_getrate(&opt.rate, &p->rate); 365 if ((p->rate.rate_bytes_ps >= (1ULL << 32)) && 366 nla_put_u64_64bit(skb, TCA_POLICE_RATE64, 367 p->rate.rate_bytes_ps, 368 TCA_POLICE_PAD)) 369 goto nla_put_failure; 370 } 371 if (p->peak_present) { 372 psched_ratecfg_getrate(&opt.peakrate, &p->peak); 373 if ((p->peak.rate_bytes_ps >= (1ULL << 32)) && 374 nla_put_u64_64bit(skb, TCA_POLICE_PEAKRATE64, 375 p->peak.rate_bytes_ps, 376 TCA_POLICE_PAD)) 377 goto nla_put_failure; 378 } 379 if (p->pps_present) { 380 if (nla_put_u64_64bit(skb, TCA_POLICE_PKTRATE64, 381 p->ppsrate.rate_pkts_ps, 382 TCA_POLICE_PAD)) 383 goto nla_put_failure; 384 if (nla_put_u64_64bit(skb, TCA_POLICE_PKTBURST64, 385 PSCHED_NS2TICKS(p->tcfp_pkt_burst), 386 TCA_POLICE_PAD)) 387 goto nla_put_failure; 388 } 389 if (nla_put(skb, TCA_POLICE_TBF, sizeof(opt), &opt)) 390 goto nla_put_failure; 391 if (p->tcfp_result && 392 nla_put_u32(skb, TCA_POLICE_RESULT, p->tcfp_result)) 393 goto nla_put_failure; 394 if (p->tcfp_ewma_rate && 395 nla_put_u32(skb, TCA_POLICE_AVRATE, p->tcfp_ewma_rate)) 396 goto nla_put_failure; 397 398 tcf_tm_dump(&t, &police->tcf_tm); 399 if (nla_put_64bit(skb, TCA_POLICE_TM, sizeof(t), &t, TCA_POLICE_PAD)) 400 goto nla_put_failure; 401 rcu_read_unlock(); 402 403 return skb->len; 404 405 nla_put_failure: 406 rcu_read_unlock(); 407 nlmsg_trim(skb, b); 408 return -1; 409 } 410 411 static int tcf_police_act_to_flow_act(int tc_act, u32 *extval, 412 struct netlink_ext_ack *extack) 413 { 414 int act_id = -EOPNOTSUPP; 415 416 if (!TC_ACT_EXT_OPCODE(tc_act)) { 417 if (tc_act == TC_ACT_OK) 418 act_id = FLOW_ACTION_ACCEPT; 419 else if (tc_act == TC_ACT_SHOT) 420 act_id = FLOW_ACTION_DROP; 421 else if (tc_act == TC_ACT_PIPE) 422 act_id = FLOW_ACTION_PIPE; 423 else if (tc_act == TC_ACT_RECLASSIFY) 424 NL_SET_ERR_MSG_MOD(extack, "Offload not supported when conform/exceed action is \"reclassify\""); 425 else 426 NL_SET_ERR_MSG_MOD(extack, "Unsupported conform/exceed action offload"); 427 } else if (TC_ACT_EXT_CMP(tc_act, TC_ACT_GOTO_CHAIN)) { 428 act_id = FLOW_ACTION_GOTO; 429 *extval = tc_act & TC_ACT_EXT_VAL_MASK; 430 } else if (TC_ACT_EXT_CMP(tc_act, TC_ACT_JUMP)) { 431 act_id = FLOW_ACTION_JUMP; 432 *extval = tc_act & TC_ACT_EXT_VAL_MASK; 433 } else if (tc_act == TC_ACT_UNSPEC) { 434 act_id = FLOW_ACTION_CONTINUE; 435 } else { 436 NL_SET_ERR_MSG_MOD(extack, "Unsupported conform/exceed action offload"); 437 } 438 439 return act_id; 440 } 441 442 static int tcf_police_offload_act_setup(struct tc_action *act, void *entry_data, 443 u32 *index_inc, bool bind, 444 struct netlink_ext_ack *extack) 445 { 446 if (bind) { 447 struct flow_action_entry *entry = entry_data; 448 struct tcf_police *police = to_police(act); 449 struct tcf_police_params *p; 450 int act_id; 451 452 p = rcu_dereference_protected(police->params, 453 lockdep_is_held(&police->tcf_lock)); 454 455 entry->id = FLOW_ACTION_POLICE; 456 entry->police.burst = tcf_police_burst(act); 457 entry->police.rate_bytes_ps = 458 tcf_police_rate_bytes_ps(act); 459 entry->police.peakrate_bytes_ps = tcf_police_peakrate_bytes_ps(act); 460 entry->police.avrate = tcf_police_tcfp_ewma_rate(act); 461 entry->police.overhead = tcf_police_rate_overhead(act); 462 entry->police.burst_pkt = tcf_police_burst_pkt(act); 463 entry->police.rate_pkt_ps = 464 tcf_police_rate_pkt_ps(act); 465 entry->police.mtu = tcf_police_tcfp_mtu(act); 466 467 act_id = tcf_police_act_to_flow_act(police->tcf_action, 468 &entry->police.exceed.extval, 469 extack); 470 if (act_id < 0) 471 return act_id; 472 473 entry->police.exceed.act_id = act_id; 474 475 act_id = tcf_police_act_to_flow_act(p->tcfp_result, 476 &entry->police.notexceed.extval, 477 extack); 478 if (act_id < 0) 479 return act_id; 480 481 entry->police.notexceed.act_id = act_id; 482 483 *index_inc = 1; 484 } else { 485 struct flow_offload_action *fl_action = entry_data; 486 487 fl_action->id = FLOW_ACTION_POLICE; 488 } 489 490 return 0; 491 } 492 493 static size_t tcf_police_get_fill_size(const struct tc_action *act) 494 { 495 return nla_total_size(sizeof(struct tc_police)) /* TCA_POLICE_TBF */ 496 + nla_total_size_64bit(sizeof(u64)) /* TCA_POLICE_RATE64 */ 497 + nla_total_size_64bit(sizeof(u64)) /* TCA_POLICE_PEAKRATE64 */ 498 + nla_total_size_64bit(sizeof(u64)) /* TCA_POLICE_PKTRATE64 */ 499 + nla_total_size_64bit(sizeof(u64)) /* TCA_POLICE_PKTBURST64 */ 500 + nla_total_size(sizeof(u32)) /* TCA_POLICE_RESULT */ 501 + nla_total_size(sizeof(u32)); /* TCA_POLICE_AVRATE */ 502 } 503 504 MODULE_AUTHOR("Alexey Kuznetsov"); 505 MODULE_DESCRIPTION("Policing actions"); 506 MODULE_LICENSE("GPL"); 507 508 static struct tc_action_ops act_police_ops = { 509 .kind = "police", 510 .id = TCA_ID_POLICE, 511 .owner = THIS_MODULE, 512 .stats_update = tcf_police_stats_update, 513 .act = tcf_police_act, 514 .dump = tcf_police_dump, 515 .init = tcf_police_init, 516 .cleanup = tcf_police_cleanup, 517 .get_fill_size = tcf_police_get_fill_size, 518 .offload_act_setup = tcf_police_offload_act_setup, 519 .size = sizeof(struct tcf_police), 520 }; 521 MODULE_ALIAS_NET_ACT("police"); 522 523 static __net_init int police_init_net(struct net *net) 524 { 525 struct tc_action_net *tn = net_generic(net, act_police_ops.net_id); 526 527 return tc_action_net_init(net, tn, &act_police_ops); 528 } 529 530 static void __net_exit police_exit_net(struct list_head *net_list) 531 { 532 tc_action_net_exit(net_list, act_police_ops.net_id); 533 } 534 535 static struct pernet_operations police_net_ops = { 536 .init = police_init_net, 537 .exit_batch = police_exit_net, 538 .id = &act_police_ops.net_id, 539 .size = sizeof(struct tc_action_net), 540 }; 541 542 static int __init police_init_module(void) 543 { 544 return tcf_register_action(&act_police_ops, &police_net_ops); 545 } 546 547 static void __exit police_cleanup_module(void) 548 { 549 tcf_unregister_action(&act_police_ops, &police_net_ops); 550 } 551 552 module_init(police_init_module); 553 module_exit(police_cleanup_module); 554