net/openvswitch/meter.c

   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 = genl_info_userhdr(info);
 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 = genl_info_userhdr(info);
 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 = genl_info_userhdr(info);
 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 = genl_info_userhdr(info);
 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 = genl_info_userhdr(info);
 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 }