projects/linux·blob master · refs

771 lines · 18.4 KiB

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