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