2 * Copyright (c) 2017 Nicira, Inc.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of version 2 of the GNU General Public
6 * License as published by the Free Software Foundation.
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/skbuff.h>
14 #include <linux/kernel.h>
15 #include <linux/openvswitch.h>
16 #include <linux/netlink.h>
17 #include <linux/rculist.h>
19 #include <net/netlink.h>
20 #include <net/genetlink.h>
25 #define METER_HASH_BUCKETS 1024
27 static const struct nla_policy meter_policy
[OVS_METER_ATTR_MAX
+ 1] = {
28 [OVS_METER_ATTR_ID
] = { .type
= NLA_U32
, },
29 [OVS_METER_ATTR_KBPS
] = { .type
= NLA_FLAG
},
30 [OVS_METER_ATTR_STATS
] = { .len
= sizeof(struct ovs_flow_stats
) },
31 [OVS_METER_ATTR_BANDS
] = { .type
= NLA_NESTED
},
32 [OVS_METER_ATTR_USED
] = { .type
= NLA_U64
},
33 [OVS_METER_ATTR_CLEAR
] = { .type
= NLA_FLAG
},
34 [OVS_METER_ATTR_MAX_METERS
] = { .type
= NLA_U32
},
35 [OVS_METER_ATTR_MAX_BANDS
] = { .type
= NLA_U32
},
38 static const struct nla_policy band_policy
[OVS_BAND_ATTR_MAX
+ 1] = {
39 [OVS_BAND_ATTR_TYPE
] = { .type
= NLA_U32
, },
40 [OVS_BAND_ATTR_RATE
] = { .type
= NLA_U32
, },
41 [OVS_BAND_ATTR_BURST
] = { .type
= NLA_U32
, },
42 [OVS_BAND_ATTR_STATS
] = { .len
= sizeof(struct ovs_flow_stats
) },
45 static void ovs_meter_free(struct dp_meter
*meter
)
50 kfree_rcu(meter
, rcu
);
53 static struct hlist_head
*meter_hash_bucket(const struct datapath
*dp
,
56 return &dp
->meters
[meter_id
& (METER_HASH_BUCKETS
- 1)];
59 /* Call with ovs_mutex or RCU read lock. */
60 static struct dp_meter
*lookup_meter(const struct datapath
*dp
,
63 struct dp_meter
*meter
;
64 struct hlist_head
*head
;
66 head
= meter_hash_bucket(dp
, meter_id
);
67 hlist_for_each_entry_rcu(meter
, head
, dp_hash_node
) {
68 if (meter
->id
== meter_id
)
74 static void attach_meter(struct datapath
*dp
, struct dp_meter
*meter
)
76 struct hlist_head
*head
= meter_hash_bucket(dp
, meter
->id
);
78 hlist_add_head_rcu(&meter
->dp_hash_node
, head
);
81 static void detach_meter(struct dp_meter
*meter
)
85 hlist_del_rcu(&meter
->dp_hash_node
);
88 static struct sk_buff
*
89 ovs_meter_cmd_reply_start(struct genl_info
*info
, u8 cmd
,
90 struct ovs_header
**ovs_reply_header
)
93 struct ovs_header
*ovs_header
= info
->userhdr
;
95 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
97 return ERR_PTR(-ENOMEM
);
99 *ovs_reply_header
= genlmsg_put(skb
, info
->snd_portid
,
101 &dp_meter_genl_family
, 0, cmd
);
102 if (!*ovs_reply_header
) {
104 return ERR_PTR(-EMSGSIZE
);
106 (*ovs_reply_header
)->dp_ifindex
= ovs_header
->dp_ifindex
;
111 static int ovs_meter_cmd_reply_stats(struct sk_buff
*reply
, u32 meter_id
,
112 struct dp_meter
*meter
)
115 struct dp_meter_band
*band
;
118 if (nla_put_u32(reply
, OVS_METER_ATTR_ID
, meter_id
))
124 if (nla_put(reply
, OVS_METER_ATTR_STATS
,
125 sizeof(struct ovs_flow_stats
), &meter
->stats
) ||
126 nla_put_u64_64bit(reply
, OVS_METER_ATTR_USED
, meter
->used
,
130 nla
= nla_nest_start(reply
, OVS_METER_ATTR_BANDS
);
136 for (i
= 0; i
< meter
->n_bands
; ++i
, ++band
) {
137 struct nlattr
*band_nla
;
139 band_nla
= nla_nest_start(reply
, OVS_BAND_ATTR_UNSPEC
);
140 if (!band_nla
|| nla_put(reply
, OVS_BAND_ATTR_STATS
,
141 sizeof(struct ovs_flow_stats
),
144 nla_nest_end(reply
, band_nla
);
146 nla_nest_end(reply
, nla
);
153 static int ovs_meter_cmd_features(struct sk_buff
*skb
, struct genl_info
*info
)
155 struct sk_buff
*reply
;
156 struct ovs_header
*ovs_reply_header
;
157 struct nlattr
*nla
, *band_nla
;
160 reply
= ovs_meter_cmd_reply_start(info
, OVS_METER_CMD_FEATURES
,
163 return PTR_ERR(reply
);
165 if (nla_put_u32(reply
, OVS_METER_ATTR_MAX_METERS
, U32_MAX
) ||
166 nla_put_u32(reply
, OVS_METER_ATTR_MAX_BANDS
, DP_MAX_BANDS
))
167 goto nla_put_failure
;
169 nla
= nla_nest_start(reply
, OVS_METER_ATTR_BANDS
);
171 goto nla_put_failure
;
173 band_nla
= nla_nest_start(reply
, OVS_BAND_ATTR_UNSPEC
);
175 goto nla_put_failure
;
176 /* Currently only DROP band type is supported. */
177 if (nla_put_u32(reply
, OVS_BAND_ATTR_TYPE
, OVS_METER_BAND_TYPE_DROP
))
178 goto nla_put_failure
;
179 nla_nest_end(reply
, band_nla
);
180 nla_nest_end(reply
, nla
);
182 genlmsg_end(reply
, ovs_reply_header
);
183 return genlmsg_reply(reply
, info
);
191 static struct dp_meter
*dp_meter_create(struct nlattr
**a
)
196 struct dp_meter
*meter
;
197 struct dp_meter_band
*band
;
200 /* Validate attributes, count the bands. */
201 if (!a
[OVS_METER_ATTR_BANDS
])
202 return ERR_PTR(-EINVAL
);
204 nla_for_each_nested(nla
, a
[OVS_METER_ATTR_BANDS
], rem
)
205 if (++n_bands
> DP_MAX_BANDS
)
206 return ERR_PTR(-EINVAL
);
208 /* Allocate and set up the meter before locking anything. */
209 meter
= kzalloc(n_bands
* sizeof(struct dp_meter_band
) +
210 sizeof(*meter
), GFP_KERNEL
);
212 return ERR_PTR(-ENOMEM
);
214 meter
->used
= div_u64(ktime_get_ns(), 1000 * 1000);
215 meter
->kbps
= a
[OVS_METER_ATTR_KBPS
] ? 1 : 0;
216 meter
->keep_stats
= !a
[OVS_METER_ATTR_CLEAR
];
217 spin_lock_init(&meter
->lock
);
218 if (meter
->keep_stats
&& a
[OVS_METER_ATTR_STATS
]) {
219 meter
->stats
= *(struct ovs_flow_stats
*)
220 nla_data(a
[OVS_METER_ATTR_STATS
]);
222 meter
->n_bands
= n_bands
;
224 /* Set up meter bands. */
226 nla_for_each_nested(nla
, a
[OVS_METER_ATTR_BANDS
], rem
) {
227 struct nlattr
*attr
[OVS_BAND_ATTR_MAX
+ 1];
228 u32 band_max_delta_t
;
230 err
= nla_parse((struct nlattr
**)&attr
, OVS_BAND_ATTR_MAX
,
231 nla_data(nla
), nla_len(nla
), band_policy
,
234 goto exit_free_meter
;
236 if (!attr
[OVS_BAND_ATTR_TYPE
] ||
237 !attr
[OVS_BAND_ATTR_RATE
] ||
238 !attr
[OVS_BAND_ATTR_BURST
]) {
240 goto exit_free_meter
;
243 band
->type
= nla_get_u32(attr
[OVS_BAND_ATTR_TYPE
]);
244 band
->rate
= nla_get_u32(attr
[OVS_BAND_ATTR_RATE
]);
245 if (band
->rate
== 0) {
247 goto exit_free_meter
;
250 band
->burst_size
= nla_get_u32(attr
[OVS_BAND_ATTR_BURST
]);
251 /* Figure out max delta_t that is enough to fill any bucket.
252 * Keep max_delta_t size to the bucket units:
253 * pkts => 1/1000 packets, kilobits => bits.
255 * Start with a full bucket.
257 band
->bucket
= (band
->burst_size
+ band
->rate
) * 1000;
258 band_max_delta_t
= band
->bucket
/ band
->rate
;
259 if (band_max_delta_t
> meter
->max_delta_t
)
260 meter
->max_delta_t
= band_max_delta_t
;
271 static int ovs_meter_cmd_set(struct sk_buff
*skb
, struct genl_info
*info
)
273 struct nlattr
**a
= info
->attrs
;
274 struct dp_meter
*meter
, *old_meter
;
275 struct sk_buff
*reply
;
276 struct ovs_header
*ovs_reply_header
;
277 struct ovs_header
*ovs_header
= info
->userhdr
;
283 meter
= dp_meter_create(a
);
284 if (IS_ERR_OR_NULL(meter
))
285 return PTR_ERR(meter
);
287 reply
= ovs_meter_cmd_reply_start(info
, OVS_METER_CMD_SET
,
290 err
= PTR_ERR(reply
);
291 goto exit_free_meter
;
295 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
301 if (!a
[OVS_METER_ATTR_ID
]) {
306 meter_id
= nla_get_u32(a
[OVS_METER_ATTR_ID
]);
308 /* Cannot fail after this. */
309 old_meter
= lookup_meter(dp
, meter_id
);
310 detach_meter(old_meter
);
311 attach_meter(dp
, meter
);
314 /* Build response with the meter_id and stats from
315 * the old meter, if any.
317 failed
= nla_put_u32(reply
, OVS_METER_ATTR_ID
, meter_id
);
320 spin_lock_bh(&old_meter
->lock
);
321 if (old_meter
->keep_stats
) {
322 err
= ovs_meter_cmd_reply_stats(reply
, meter_id
,
326 spin_unlock_bh(&old_meter
->lock
);
327 ovs_meter_free(old_meter
);
330 genlmsg_end(reply
, ovs_reply_header
);
331 return genlmsg_reply(reply
, info
);
341 static int ovs_meter_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
343 struct nlattr
**a
= info
->attrs
;
345 struct ovs_header
*ovs_header
= info
->userhdr
;
346 struct ovs_header
*ovs_reply_header
;
349 struct sk_buff
*reply
;
350 struct dp_meter
*meter
;
352 if (!a
[OVS_METER_ATTR_ID
])
355 meter_id
= nla_get_u32(a
[OVS_METER_ATTR_ID
]);
357 reply
= ovs_meter_cmd_reply_start(info
, OVS_METER_CMD_GET
,
360 return PTR_ERR(reply
);
364 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
370 /* Locate meter, copy stats. */
371 meter
= lookup_meter(dp
, meter_id
);
377 spin_lock_bh(&meter
->lock
);
378 err
= ovs_meter_cmd_reply_stats(reply
, meter_id
, meter
);
379 spin_unlock_bh(&meter
->lock
);
385 genlmsg_end(reply
, ovs_reply_header
);
386 return genlmsg_reply(reply
, info
);
394 static int ovs_meter_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
396 struct nlattr
**a
= info
->attrs
;
398 struct ovs_header
*ovs_header
= info
->userhdr
;
399 struct ovs_header
*ovs_reply_header
;
402 struct sk_buff
*reply
;
403 struct dp_meter
*old_meter
;
405 if (!a
[OVS_METER_ATTR_ID
])
407 meter_id
= nla_get_u32(a
[OVS_METER_ATTR_ID
]);
409 reply
= ovs_meter_cmd_reply_start(info
, OVS_METER_CMD_DEL
,
412 return PTR_ERR(reply
);
416 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
422 old_meter
= lookup_meter(dp
, meter_id
);
424 spin_lock_bh(&old_meter
->lock
);
425 err
= ovs_meter_cmd_reply_stats(reply
, meter_id
, old_meter
);
427 spin_unlock_bh(&old_meter
->lock
);
428 detach_meter(old_meter
);
431 ovs_meter_free(old_meter
);
432 genlmsg_end(reply
, ovs_reply_header
);
433 return genlmsg_reply(reply
, info
);
441 /* Meter action execution.
443 * Return true 'meter_id' drop band is triggered. The 'skb' should be
444 * dropped by the caller'.
446 bool ovs_meter_execute(struct datapath
*dp
, struct sk_buff
*skb
,
447 struct sw_flow_key
*key
, u32 meter_id
)
449 struct dp_meter
*meter
;
450 struct dp_meter_band
*band
;
451 long long int now_ms
= div_u64(ktime_get_ns(), 1000 * 1000);
452 long long int long_delta_ms
;
455 int i
, band_exceeded_max
= -1;
456 u32 band_exceeded_rate
= 0;
458 meter
= lookup_meter(dp
, meter_id
);
459 /* Do not drop the packet when there is no meter. */
463 /* Lock the meter while using it. */
464 spin_lock(&meter
->lock
);
466 long_delta_ms
= (now_ms
- meter
->used
); /* ms */
468 /* Make sure delta_ms will not be too large, so that bucket will not
471 delta_ms
= (long_delta_ms
> (long long int)meter
->max_delta_t
)
472 ? meter
->max_delta_t
: (u32
)long_delta_ms
;
474 /* Update meter statistics.
476 meter
->used
= now_ms
;
477 meter
->stats
.n_packets
+= 1;
478 meter
->stats
.n_bytes
+= skb
->len
;
480 /* Bucket rate is either in kilobits per second, or in packets per
481 * second. We maintain the bucket in the units of either bits or
482 * 1/1000th of a packet, correspondingly.
483 * Then, when rate is multiplied with milliseconds, we get the
485 * msec * kbps = bits, and
486 * msec * packets/sec = 1/1000 packets.
488 * 'cost' is the number of bucket units in this packet.
490 cost
= (meter
->kbps
) ? skb
->len
* 8 : 1000;
492 /* Update all bands and find the one hit with the highest rate. */
493 for (i
= 0; i
< meter
->n_bands
; ++i
) {
494 long long int max_bucket_size
;
496 band
= &meter
->bands
[i
];
497 max_bucket_size
= (band
->burst_size
+ band
->rate
) * 1000;
499 band
->bucket
+= delta_ms
* band
->rate
;
500 if (band
->bucket
> max_bucket_size
)
501 band
->bucket
= max_bucket_size
;
503 if (band
->bucket
>= cost
) {
504 band
->bucket
-= cost
;
505 } else if (band
->rate
> band_exceeded_rate
) {
506 band_exceeded_rate
= band
->rate
;
507 band_exceeded_max
= i
;
511 if (band_exceeded_max
>= 0) {
512 /* Update band statistics. */
513 band
= &meter
->bands
[band_exceeded_max
];
514 band
->stats
.n_packets
+= 1;
515 band
->stats
.n_bytes
+= skb
->len
;
517 /* Drop band triggered, let the caller drop the 'skb'. */
518 if (band
->type
== OVS_METER_BAND_TYPE_DROP
) {
519 spin_unlock(&meter
->lock
);
524 spin_unlock(&meter
->lock
);
528 static struct genl_ops dp_meter_genl_ops
[] = {
529 { .cmd
= OVS_METER_CMD_FEATURES
,
530 .flags
= 0, /* OK for unprivileged users. */
531 .policy
= meter_policy
,
532 .doit
= ovs_meter_cmd_features
534 { .cmd
= OVS_METER_CMD_SET
,
535 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN
538 .policy
= meter_policy
,
539 .doit
= ovs_meter_cmd_set
,
541 { .cmd
= OVS_METER_CMD_GET
,
542 .flags
= 0, /* OK for unprivileged users. */
543 .policy
= meter_policy
,
544 .doit
= ovs_meter_cmd_get
,
546 { .cmd
= OVS_METER_CMD_DEL
,
547 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN
550 .policy
= meter_policy
,
551 .doit
= ovs_meter_cmd_del
555 static const struct genl_multicast_group ovs_meter_multicast_group
= {
556 .name
= OVS_METER_MCGROUP
,
559 struct genl_family dp_meter_genl_family __ro_after_init
= {
560 .hdrsize
= sizeof(struct ovs_header
),
561 .name
= OVS_METER_FAMILY
,
562 .version
= OVS_METER_VERSION
,
563 .maxattr
= OVS_METER_ATTR_MAX
,
565 .parallel_ops
= true,
566 .ops
= dp_meter_genl_ops
,
567 .n_ops
= ARRAY_SIZE(dp_meter_genl_ops
),
568 .mcgrps
= &ovs_meter_multicast_group
,
570 .module
= THIS_MODULE
,
573 int ovs_meters_init(struct datapath
*dp
)
577 dp
->meters
= kmalloc_array(METER_HASH_BUCKETS
,
578 sizeof(struct hlist_head
), GFP_KERNEL
);
583 for (i
= 0; i
< METER_HASH_BUCKETS
; i
++)
584 INIT_HLIST_HEAD(&dp
->meters
[i
]);
589 void ovs_meters_exit(struct datapath
*dp
)
593 for (i
= 0; i
< METER_HASH_BUCKETS
; i
++) {
594 struct hlist_head
*head
= &dp
->meters
[i
];
595 struct dp_meter
*meter
;
596 struct hlist_node
*n
;
598 hlist_for_each_entry_safe(meter
, n
, head
, dp_hash_node
)