1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2017 Nicira, Inc. 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/if.h> 9 #include <linux/skbuff.h> 10 #include <linux/ip.h> 11 #include <linux/kernel.h> 12 #include <linux/openvswitch.h> 13 #include <linux/netlink.h> 14 #include <linux/rculist.h> 15 16 #include <net/netlink.h> 17 #include <net/genetlink.h> 18 19 #include "datapath.h" 20 #include "meter.h" 21 22 static const struct nla_policy meter_policy[OVS_METER_ATTR_MAX + 1] = { 23 [OVS_METER_ATTR_ID] = { .type = NLA_U32, }, 24 [OVS_METER_ATTR_KBPS] = { .type = NLA_FLAG }, 25 [OVS_METER_ATTR_STATS] = { .len = sizeof(struct ovs_flow_stats) }, 26 [OVS_METER_ATTR_BANDS] = { .type = NLA_NESTED }, 27 [OVS_METER_ATTR_USED] = { .type = NLA_U64 }, 28 [OVS_METER_ATTR_CLEAR] = { .type = NLA_FLAG }, 29 [OVS_METER_ATTR_MAX_METERS] = { .type = NLA_U32 }, 30 [OVS_METER_ATTR_MAX_BANDS] = { .type = NLA_U32 }, 31 }; 32 33 static const struct nla_policy band_policy[OVS_BAND_ATTR_MAX + 1] = { 34 [OVS_BAND_ATTR_TYPE] = { .type = NLA_U32, }, 35 [OVS_BAND_ATTR_RATE] = { .type = NLA_U32, }, 36 [OVS_BAND_ATTR_BURST] = { .type = NLA_U32, }, 37 [OVS_BAND_ATTR_STATS] = { .len = sizeof(struct ovs_flow_stats) }, 38 }; 39 40 static u32 meter_hash(struct dp_meter_instance *ti, u32 id) 41 { 42 return id % ti->n_meters; 43 } 44 45 static void ovs_meter_free(struct dp_meter *meter) 46 { 47 if (!meter) 48 return; 49 50 kfree_rcu(meter, rcu); 51 } 52 53 /* Call with ovs_mutex or RCU read lock. */ 54 static struct dp_meter *lookup_meter(const struct dp_meter_table *tbl, 55 u32 meter_id) 56 { 57 struct dp_meter_instance *ti = rcu_dereference_ovsl(tbl->ti); 58 u32 hash = meter_hash(ti, meter_id); 59 struct dp_meter *meter; 60 61 meter = rcu_dereference_ovsl(ti->dp_meters[hash]); 62 if (meter && likely(meter->id == meter_id)) 63 return meter; 64 65 return NULL; 66 } 67 68 static struct dp_meter_instance *dp_meter_instance_alloc(const u32 size) 69 { 70 struct dp_meter_instance *ti; 71 72 ti = kvzalloc(sizeof(*ti) + 73 sizeof(struct dp_meter *) * size, 74 GFP_KERNEL); 75 if (!ti) 76 return NULL; 77 78 ti->n_meters = size; 79 80 return ti; 81 } 82 83 static void dp_meter_instance_free(struct dp_meter_instance *ti) 84 { 85 kvfree(ti); 86 } 87 88 static void dp_meter_instance_free_rcu(struct rcu_head *rcu) 89 { 90 struct dp_meter_instance *ti; 91 92 ti = container_of(rcu, struct dp_meter_instance, rcu); 93 kvfree(ti); 94 } 95 96 static int 97 dp_meter_instance_realloc(struct dp_meter_table *tbl, u32 size) 98 { 99 struct dp_meter_instance *ti = rcu_dereference_ovsl(tbl->ti); 100 int n_meters = min(size, ti->n_meters); 101 struct dp_meter_instance *new_ti; 102 int i; 103 104 new_ti = dp_meter_instance_alloc(size); 105 if (!new_ti) 106 return -ENOMEM; 107 108 for (i = 0; i < n_meters; i++) 109 if (rcu_dereference_ovsl(ti->dp_meters[i])) 110 new_ti->dp_meters[i] = ti->dp_meters[i]; 111 112 rcu_assign_pointer(tbl->ti, new_ti); 113 call_rcu(&ti->rcu, dp_meter_instance_free_rcu); 114 115 return 0; 116 } 117 118 static void dp_meter_instance_insert(struct dp_meter_instance *ti, 119 struct dp_meter *meter) 120 { 121 u32 hash; 122 123 hash = meter_hash(ti, meter->id); 124 rcu_assign_pointer(ti->dp_meters[hash], meter); 125 } 126 127 static void dp_meter_instance_remove(struct dp_meter_instance *ti, 128 struct dp_meter *meter) 129 { 130 u32 hash; 131 132 hash = meter_hash(ti, meter->id); 133 RCU_INIT_POINTER(ti->dp_meters[hash], NULL); 134 } 135 136 static int attach_meter(struct dp_meter_table *tbl, struct dp_meter *meter) 137 { 138 struct dp_meter_instance *ti = rcu_dereference_ovsl(tbl->ti); 139 u32 hash = meter_hash(ti, meter->id); 140 int err; 141 142 /* In generally, slots selected should be empty, because 143 * OvS uses id-pool to fetch a available id. 144 */ 145 if (unlikely(rcu_dereference_ovsl(ti->dp_meters[hash]))) 146 return -EBUSY; 147 148 dp_meter_instance_insert(ti, meter); 149 150 /* That function is thread-safe. */ 151 tbl->count++; 152 if (tbl->count >= tbl->max_meters_allowed) { 153 err = -EFBIG; 154 goto attach_err; 155 } 156 157 if (tbl->count >= ti->n_meters && 158 dp_meter_instance_realloc(tbl, ti->n_meters * 2)) { 159 err = -ENOMEM; 160 goto attach_err; 161 } 162 163 return 0; 164 165 attach_err: 166 dp_meter_instance_remove(ti, meter); 167 tbl->count--; 168 return err; 169 } 170 171 static int detach_meter(struct dp_meter_table *tbl, struct dp_meter *meter) 172 { 173 struct dp_meter_instance *ti; 174 175 ASSERT_OVSL(); 176 if (!meter) 177 return 0; 178 179 ti = rcu_dereference_ovsl(tbl->ti); 180 dp_meter_instance_remove(ti, meter); 181 182 tbl->count--; 183 184 /* Shrink the meter array if necessary. */ 185 if (ti->n_meters > DP_METER_ARRAY_SIZE_MIN && 186 tbl->count <= (ti->n_meters / 4)) { 187 int half_size = ti->n_meters / 2; 188 int i; 189 190 /* Avoid hash collision, don't move slots to other place. 191 * Make sure there are no references of meters in array 192 * which will be released. 193 */ 194 for (i = half_size; i < ti->n_meters; i++) 195 if (rcu_dereference_ovsl(ti->dp_meters[i])) 196 goto out; 197 198 if (dp_meter_instance_realloc(tbl, half_size)) 199 goto shrink_err; 200 } 201 202 out: 203 return 0; 204 205 shrink_err: 206 dp_meter_instance_insert(ti, meter); 207 tbl->count++; 208 return -ENOMEM; 209 } 210 211 static struct sk_buff * 212 ovs_meter_cmd_reply_start(struct genl_info *info, u8 cmd, 213 struct ovs_header **ovs_reply_header) 214 { 215 struct sk_buff *skb; 216 struct ovs_header *ovs_header = info->userhdr; 217 218 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 219 if (!skb) 220 return ERR_PTR(-ENOMEM); 221 222 *ovs_reply_header = genlmsg_put(skb, info->snd_portid, 223 info->snd_seq, 224 &dp_meter_genl_family, 0, cmd); 225 if (!*ovs_reply_header) { 226 nlmsg_free(skb); 227 return ERR_PTR(-EMSGSIZE); 228 } 229 (*ovs_reply_header)->dp_ifindex = ovs_header->dp_ifindex; 230 231 return skb; 232 } 233 234 static int ovs_meter_cmd_reply_stats(struct sk_buff *reply, u32 meter_id, 235 struct dp_meter *meter) 236 { 237 struct nlattr *nla; 238 struct dp_meter_band *band; 239 u16 i; 240 241 if (nla_put_u32(reply, OVS_METER_ATTR_ID, meter_id)) 242 goto error; 243 244 if (nla_put(reply, OVS_METER_ATTR_STATS, 245 sizeof(struct ovs_flow_stats), &meter->stats)) 246 goto error; 247 248 if (nla_put_u64_64bit(reply, OVS_METER_ATTR_USED, meter->used, 249 OVS_METER_ATTR_PAD)) 250 goto error; 251 252 nla = nla_nest_start_noflag(reply, OVS_METER_ATTR_BANDS); 253 if (!nla) 254 goto error; 255 256 band = meter->bands; 257 258 for (i = 0; i < meter->n_bands; ++i, ++band) { 259 struct nlattr *band_nla; 260 261 band_nla = nla_nest_start_noflag(reply, OVS_BAND_ATTR_UNSPEC); 262 if (!band_nla || nla_put(reply, OVS_BAND_ATTR_STATS, 263 sizeof(struct ovs_flow_stats), 264 &band->stats)) 265 goto error; 266 nla_nest_end(reply, band_nla); 267 } 268 nla_nest_end(reply, nla); 269 270 return 0; 271 error: 272 return -EMSGSIZE; 273 } 274 275 static int ovs_meter_cmd_features(struct sk_buff *skb, struct genl_info *info) 276 { 277 struct ovs_header *ovs_header = info->userhdr; 278 struct ovs_header *ovs_reply_header; 279 struct nlattr *nla, *band_nla; 280 struct sk_buff *reply; 281 struct datapath *dp; 282 int err = -EMSGSIZE; 283 284 reply = ovs_meter_cmd_reply_start(info, OVS_METER_CMD_FEATURES, 285 &ovs_reply_header); 286 if (IS_ERR(reply)) 287 return PTR_ERR(reply); 288 289 ovs_lock(); 290 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 291 if (!dp) { 292 err = -ENODEV; 293 goto exit_unlock; 294 } 295 296 if (nla_put_u32(reply, OVS_METER_ATTR_MAX_METERS, 297 dp->meter_tbl.max_meters_allowed)) 298 goto exit_unlock; 299 300 ovs_unlock(); 301 302 if (nla_put_u32(reply, OVS_METER_ATTR_MAX_BANDS, DP_MAX_BANDS)) 303 goto nla_put_failure; 304 305 nla = nla_nest_start_noflag(reply, OVS_METER_ATTR_BANDS); 306 if (!nla) 307 goto nla_put_failure; 308 309 band_nla = nla_nest_start_noflag(reply, OVS_BAND_ATTR_UNSPEC); 310 if (!band_nla) 311 goto nla_put_failure; 312 /* Currently only DROP band type is supported. */ 313 if (nla_put_u32(reply, OVS_BAND_ATTR_TYPE, OVS_METER_BAND_TYPE_DROP)) 314 goto nla_put_failure; 315 nla_nest_end(reply, band_nla); 316 nla_nest_end(reply, nla); 317 318 genlmsg_end(reply, ovs_reply_header); 319 return genlmsg_reply(reply, info); 320 321 exit_unlock: 322 ovs_unlock(); 323 nla_put_failure: 324 nlmsg_free(reply); 325 return err; 326 } 327 328 static struct dp_meter *dp_meter_create(struct nlattr **a) 329 { 330 struct nlattr *nla; 331 int rem; 332 u16 n_bands = 0; 333 struct dp_meter *meter; 334 struct dp_meter_band *band; 335 int err; 336 337 /* Validate attributes, count the bands. */ 338 if (!a[OVS_METER_ATTR_BANDS]) 339 return ERR_PTR(-EINVAL); 340 341 nla_for_each_nested(nla, a[OVS_METER_ATTR_BANDS], rem) 342 if (++n_bands > DP_MAX_BANDS) 343 return ERR_PTR(-EINVAL); 344 345 /* Allocate and set up the meter before locking anything. */ 346 meter = kzalloc(struct_size(meter, bands, n_bands), GFP_KERNEL_ACCOUNT); 347 if (!meter) 348 return ERR_PTR(-ENOMEM); 349 350 meter->id = nla_get_u32(a[OVS_METER_ATTR_ID]); 351 meter->used = div_u64(ktime_get_ns(), 1000 * 1000); 352 meter->kbps = a[OVS_METER_ATTR_KBPS] ? 1 : 0; 353 meter->keep_stats = !a[OVS_METER_ATTR_CLEAR]; 354 spin_lock_init(&meter->lock); 355 if (meter->keep_stats && a[OVS_METER_ATTR_STATS]) { 356 meter->stats = *(struct ovs_flow_stats *) 357 nla_data(a[OVS_METER_ATTR_STATS]); 358 } 359 meter->n_bands = n_bands; 360 361 /* Set up meter bands. */ 362 band = meter->bands; 363 nla_for_each_nested(nla, a[OVS_METER_ATTR_BANDS], rem) { 364 struct nlattr *attr[OVS_BAND_ATTR_MAX + 1]; 365 u32 band_max_delta_t; 366 367 err = nla_parse_deprecated((struct nlattr **)&attr, 368 OVS_BAND_ATTR_MAX, nla_data(nla), 369 nla_len(nla), band_policy, NULL); 370 if (err) 371 goto exit_free_meter; 372 373 if (!attr[OVS_BAND_ATTR_TYPE] || 374 !attr[OVS_BAND_ATTR_RATE] || 375 !attr[OVS_BAND_ATTR_BURST]) { 376 err = -EINVAL; 377 goto exit_free_meter; 378 } 379 380 band->type = nla_get_u32(attr[OVS_BAND_ATTR_TYPE]); 381 band->rate = nla_get_u32(attr[OVS_BAND_ATTR_RATE]); 382 if (band->rate == 0) { 383 err = -EINVAL; 384 goto exit_free_meter; 385 } 386 387 band->burst_size = nla_get_u32(attr[OVS_BAND_ATTR_BURST]); 388 /* Figure out max delta_t that is enough to fill any bucket. 389 * Keep max_delta_t size to the bucket units: 390 * pkts => 1/1000 packets, kilobits => bits. 391 * 392 * Start with a full bucket. 393 */ 394 band->bucket = band->burst_size * 1000ULL; 395 band_max_delta_t = div_u64(band->bucket, band->rate); 396 if (band_max_delta_t > meter->max_delta_t) 397 meter->max_delta_t = band_max_delta_t; 398 band++; 399 } 400 401 return meter; 402 403 exit_free_meter: 404 kfree(meter); 405 return ERR_PTR(err); 406 } 407 408 static int ovs_meter_cmd_set(struct sk_buff *skb, struct genl_info *info) 409 { 410 struct nlattr **a = info->attrs; 411 struct dp_meter *meter, *old_meter; 412 struct sk_buff *reply; 413 struct ovs_header *ovs_reply_header; 414 struct ovs_header *ovs_header = info->userhdr; 415 struct dp_meter_table *meter_tbl; 416 struct datapath *dp; 417 int err; 418 u32 meter_id; 419 bool failed; 420 421 if (!a[OVS_METER_ATTR_ID]) 422 return -EINVAL; 423 424 meter = dp_meter_create(a); 425 if (IS_ERR(meter)) 426 return PTR_ERR(meter); 427 428 reply = ovs_meter_cmd_reply_start(info, OVS_METER_CMD_SET, 429 &ovs_reply_header); 430 if (IS_ERR(reply)) { 431 err = PTR_ERR(reply); 432 goto exit_free_meter; 433 } 434 435 ovs_lock(); 436 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 437 if (!dp) { 438 err = -ENODEV; 439 goto exit_unlock; 440 } 441 442 meter_tbl = &dp->meter_tbl; 443 meter_id = nla_get_u32(a[OVS_METER_ATTR_ID]); 444 445 old_meter = lookup_meter(meter_tbl, meter_id); 446 err = detach_meter(meter_tbl, old_meter); 447 if (err) 448 goto exit_unlock; 449 450 err = attach_meter(meter_tbl, meter); 451 if (err) 452 goto exit_free_old_meter; 453 454 ovs_unlock(); 455 456 /* Build response with the meter_id and stats from 457 * the old meter, if any. 458 */ 459 failed = nla_put_u32(reply, OVS_METER_ATTR_ID, meter_id); 460 WARN_ON(failed); 461 if (old_meter) { 462 spin_lock_bh(&old_meter->lock); 463 if (old_meter->keep_stats) { 464 err = ovs_meter_cmd_reply_stats(reply, meter_id, 465 old_meter); 466 WARN_ON(err); 467 } 468 spin_unlock_bh(&old_meter->lock); 469 ovs_meter_free(old_meter); 470 } 471 472 genlmsg_end(reply, ovs_reply_header); 473 return genlmsg_reply(reply, info); 474 475 exit_free_old_meter: 476 ovs_meter_free(old_meter); 477 exit_unlock: 478 ovs_unlock(); 479 nlmsg_free(reply); 480 exit_free_meter: 481 kfree(meter); 482 return err; 483 } 484 485 static int ovs_meter_cmd_get(struct sk_buff *skb, struct genl_info *info) 486 { 487 struct ovs_header *ovs_header = info->userhdr; 488 struct ovs_header *ovs_reply_header; 489 struct nlattr **a = info->attrs; 490 struct dp_meter *meter; 491 struct sk_buff *reply; 492 struct datapath *dp; 493 u32 meter_id; 494 int err; 495 496 if (!a[OVS_METER_ATTR_ID]) 497 return -EINVAL; 498 499 meter_id = nla_get_u32(a[OVS_METER_ATTR_ID]); 500 501 reply = ovs_meter_cmd_reply_start(info, OVS_METER_CMD_GET, 502 &ovs_reply_header); 503 if (IS_ERR(reply)) 504 return PTR_ERR(reply); 505 506 ovs_lock(); 507 508 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 509 if (!dp) { 510 err = -ENODEV; 511 goto exit_unlock; 512 } 513 514 /* Locate meter, copy stats. */ 515 meter = lookup_meter(&dp->meter_tbl, meter_id); 516 if (!meter) { 517 err = -ENOENT; 518 goto exit_unlock; 519 } 520 521 spin_lock_bh(&meter->lock); 522 err = ovs_meter_cmd_reply_stats(reply, meter_id, meter); 523 spin_unlock_bh(&meter->lock); 524 if (err) 525 goto exit_unlock; 526 527 ovs_unlock(); 528 529 genlmsg_end(reply, ovs_reply_header); 530 return genlmsg_reply(reply, info); 531 532 exit_unlock: 533 ovs_unlock(); 534 nlmsg_free(reply); 535 return err; 536 } 537 538 static int ovs_meter_cmd_del(struct sk_buff *skb, struct genl_info *info) 539 { 540 struct ovs_header *ovs_header = info->userhdr; 541 struct ovs_header *ovs_reply_header; 542 struct nlattr **a = info->attrs; 543 struct dp_meter *old_meter; 544 struct sk_buff *reply; 545 struct datapath *dp; 546 u32 meter_id; 547 int err; 548 549 if (!a[OVS_METER_ATTR_ID]) 550 return -EINVAL; 551 552 reply = ovs_meter_cmd_reply_start(info, OVS_METER_CMD_DEL, 553 &ovs_reply_header); 554 if (IS_ERR(reply)) 555 return PTR_ERR(reply); 556 557 ovs_lock(); 558 559 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 560 if (!dp) { 561 err = -ENODEV; 562 goto exit_unlock; 563 } 564 565 meter_id = nla_get_u32(a[OVS_METER_ATTR_ID]); 566 old_meter = lookup_meter(&dp->meter_tbl, meter_id); 567 if (old_meter) { 568 spin_lock_bh(&old_meter->lock); 569 err = ovs_meter_cmd_reply_stats(reply, meter_id, old_meter); 570 WARN_ON(err); 571 spin_unlock_bh(&old_meter->lock); 572 573 err = detach_meter(&dp->meter_tbl, old_meter); 574 if (err) 575 goto exit_unlock; 576 } 577 578 ovs_unlock(); 579 ovs_meter_free(old_meter); 580 genlmsg_end(reply, ovs_reply_header); 581 return genlmsg_reply(reply, info); 582 583 exit_unlock: 584 ovs_unlock(); 585 nlmsg_free(reply); 586 return err; 587 } 588 589 /* Meter action execution. 590 * 591 * Return true 'meter_id' drop band is triggered. The 'skb' should be 592 * dropped by the caller'. 593 */ 594 bool ovs_meter_execute(struct datapath *dp, struct sk_buff *skb, 595 struct sw_flow_key *key, u32 meter_id) 596 { 597 long long int now_ms = div_u64(ktime_get_ns(), 1000 * 1000); 598 long long int long_delta_ms; 599 struct dp_meter_band *band; 600 struct dp_meter *meter; 601 int i, band_exceeded_max = -1; 602 u32 band_exceeded_rate = 0; 603 u32 delta_ms; 604 u32 cost; 605 606 meter = lookup_meter(&dp->meter_tbl, meter_id); 607 /* Do not drop the packet when there is no meter. */ 608 if (!meter) 609 return false; 610 611 /* Lock the meter while using it. */ 612 spin_lock(&meter->lock); 613 614 long_delta_ms = (now_ms - meter->used); /* ms */ 615 if (long_delta_ms < 0) { 616 /* This condition means that we have several threads fighting 617 * for a meter lock, and the one who received the packets a 618 * bit later wins. Assuming that all racing threads received 619 * packets at the same time to avoid overflow. 620 */ 621 long_delta_ms = 0; 622 } 623 624 /* Make sure delta_ms will not be too large, so that bucket will not 625 * wrap around below. 626 */ 627 delta_ms = (long_delta_ms > (long long int)meter->max_delta_t) 628 ? meter->max_delta_t : (u32)long_delta_ms; 629 630 /* Update meter statistics. 631 */ 632 meter->used = now_ms; 633 meter->stats.n_packets += 1; 634 meter->stats.n_bytes += skb->len; 635 636 /* Bucket rate is either in kilobits per second, or in packets per 637 * second. We maintain the bucket in the units of either bits or 638 * 1/1000th of a packet, correspondingly. 639 * Then, when rate is multiplied with milliseconds, we get the 640 * bucket units: 641 * msec * kbps = bits, and 642 * msec * packets/sec = 1/1000 packets. 643 * 644 * 'cost' is the number of bucket units in this packet. 645 */ 646 cost = (meter->kbps) ? skb->len * 8 : 1000; 647 648 /* Update all bands and find the one hit with the highest rate. */ 649 for (i = 0; i < meter->n_bands; ++i) { 650 long long int max_bucket_size; 651 652 band = &meter->bands[i]; 653 max_bucket_size = band->burst_size * 1000LL; 654 655 band->bucket += delta_ms * band->rate; 656 if (band->bucket > max_bucket_size) 657 band->bucket = max_bucket_size; 658 659 if (band->bucket >= cost) { 660 band->bucket -= cost; 661 } else if (band->rate > band_exceeded_rate) { 662 band_exceeded_rate = band->rate; 663 band_exceeded_max = i; 664 } 665 } 666 667 if (band_exceeded_max >= 0) { 668 /* Update band statistics. */ 669 band = &meter->bands[band_exceeded_max]; 670 band->stats.n_packets += 1; 671 band->stats.n_bytes += skb->len; 672 673 /* Drop band triggered, let the caller drop the 'skb'. */ 674 if (band->type == OVS_METER_BAND_TYPE_DROP) { 675 spin_unlock(&meter->lock); 676 return true; 677 } 678 } 679 680 spin_unlock(&meter->lock); 681 return false; 682 } 683 684 static const struct genl_small_ops dp_meter_genl_ops[] = { 685 { .cmd = OVS_METER_CMD_FEATURES, 686 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 687 .flags = 0, /* OK for unprivileged users. */ 688 .doit = ovs_meter_cmd_features 689 }, 690 { .cmd = OVS_METER_CMD_SET, 691 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 692 .flags = GENL_UNS_ADMIN_PERM, /* Requires CAP_NET_ADMIN 693 * privilege. 694 */ 695 .doit = ovs_meter_cmd_set, 696 }, 697 { .cmd = OVS_METER_CMD_GET, 698 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 699 .flags = 0, /* OK for unprivileged users. */ 700 .doit = ovs_meter_cmd_get, 701 }, 702 { .cmd = OVS_METER_CMD_DEL, 703 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 704 .flags = GENL_UNS_ADMIN_PERM, /* Requires CAP_NET_ADMIN 705 * privilege. 706 */ 707 .doit = ovs_meter_cmd_del 708 }, 709 }; 710 711 static const struct genl_multicast_group ovs_meter_multicast_group = { 712 .name = OVS_METER_MCGROUP, 713 }; 714 715 struct genl_family dp_meter_genl_family __ro_after_init = { 716 .hdrsize = sizeof(struct ovs_header), 717 .name = OVS_METER_FAMILY, 718 .version = OVS_METER_VERSION, 719 .maxattr = OVS_METER_ATTR_MAX, 720 .policy = meter_policy, 721 .netnsok = true, 722 .parallel_ops = true, 723 .small_ops = dp_meter_genl_ops, 724 .n_small_ops = ARRAY_SIZE(dp_meter_genl_ops), 725 .resv_start_op = OVS_METER_CMD_GET + 1, 726 .mcgrps = &ovs_meter_multicast_group, 727 .n_mcgrps = 1, 728 .module = THIS_MODULE, 729 }; 730 731 int ovs_meters_init(struct datapath *dp) 732 { 733 struct dp_meter_table *tbl = &dp->meter_tbl; 734 struct dp_meter_instance *ti; 735 unsigned long free_mem_bytes; 736 737 ti = dp_meter_instance_alloc(DP_METER_ARRAY_SIZE_MIN); 738 if (!ti) 739 return -ENOMEM; 740 741 /* Allow meters in a datapath to use ~3.12% of physical memory. */ 742 free_mem_bytes = nr_free_buffer_pages() * (PAGE_SIZE >> 5); 743 tbl->max_meters_allowed = min(free_mem_bytes / sizeof(struct dp_meter), 744 DP_METER_NUM_MAX); 745 if (!tbl->max_meters_allowed) 746 goto out_err; 747 748 rcu_assign_pointer(tbl->ti, ti); 749 tbl->count = 0; 750 751 return 0; 752 753 out_err: 754 dp_meter_instance_free(ti); 755 return -ENOMEM; 756 } 757 758 void ovs_meters_exit(struct datapath *dp) 759 { 760 struct dp_meter_table *tbl = &dp->meter_tbl; 761 struct dp_meter_instance *ti = rcu_dereference_raw(tbl->ti); 762 int i; 763 764 for (i = 0; i < ti->n_meters; i++) 765 ovs_meter_free(rcu_dereference_raw(ti->dp_meters[i])); 766 767 dp_meter_instance_free(ti); 768 } 769