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