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(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 }