1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#include <linux/rhashtable.h>
#include <net/flow_offload.h>
#include "en/tc_priv.h"
#include "act_stats.h"
#include "en/fs.h"
struct mlx5e_tc_act_stats_handle {
struct rhashtable ht;
spinlock_t ht_lock; /* protects hashtable */
};
struct mlx5e_tc_act_stats {
unsigned long tc_act_cookie;
struct mlx5_fc *counter;
u64 lastpackets;
u64 lastbytes;
struct rhash_head hash;
struct rcu_head rcu_head;
};
static const struct rhashtable_params act_counters_ht_params = {
.head_offset = offsetof(struct mlx5e_tc_act_stats, hash),
.key_offset = 0,
.key_len = offsetof(struct mlx5e_tc_act_stats, counter),
.automatic_shrinking = true,
};
struct mlx5e_tc_act_stats_handle *
mlx5e_tc_act_stats_create(void)
{
struct mlx5e_tc_act_stats_handle *handle;
int err;
handle = kvzalloc(sizeof(*handle), GFP_KERNEL);
if (IS_ERR(handle))
return ERR_PTR(-ENOMEM);
err = rhashtable_init(&handle->ht, &act_counters_ht_params);
if (err)
goto err;
spin_lock_init(&handle->ht_lock);
return handle;
err:
kvfree(handle);
return ERR_PTR(err);
}
void mlx5e_tc_act_stats_free(struct mlx5e_tc_act_stats_handle *handle)
{
rhashtable_destroy(&handle->ht);
kvfree(handle);
}
static int
mlx5e_tc_act_stats_add(struct mlx5e_tc_act_stats_handle *handle,
unsigned long act_cookie,
struct mlx5_fc *counter)
{
struct mlx5e_tc_act_stats *act_stats, *old_act_stats;
struct rhashtable *ht = &handle->ht;
int err = 0;
act_stats = kvzalloc(sizeof(*act_stats), GFP_KERNEL);
if (!act_stats)
return -ENOMEM;
act_stats->tc_act_cookie = act_cookie;
act_stats->counter = counter;
rcu_read_lock();
old_act_stats = rhashtable_lookup_get_insert_fast(ht,
&act_stats->hash,
act_counters_ht_params);
if (IS_ERR(old_act_stats)) {
err = PTR_ERR(old_act_stats);
goto err_hash_insert;
} else if (old_act_stats) {
err = -EEXIST;
goto err_hash_insert;
}
rcu_read_unlock();
return 0;
err_hash_insert:
rcu_read_unlock();
kvfree(act_stats);
return err;
}
void
mlx5e_tc_act_stats_del_flow(struct mlx5e_tc_act_stats_handle *handle,
struct mlx5e_tc_flow *flow)
{
struct mlx5_flow_attr *attr;
struct mlx5e_tc_act_stats *act_stats;
int i;
if (!flow_flag_test(flow, USE_ACT_STATS))
return;
list_for_each_entry(attr, &flow->attrs, list) {
for (i = 0; i < attr->tc_act_cookies_count; i++) {
struct rhashtable *ht = &handle->ht;
spin_lock(&handle->ht_lock);
act_stats = rhashtable_lookup_fast(ht,
&attr->tc_act_cookies[i],
act_counters_ht_params);
if (act_stats &&
rhashtable_remove_fast(ht, &act_stats->hash,
act_counters_ht_params) == 0)
kvfree_rcu(act_stats, rcu_head);
spin_unlock(&handle->ht_lock);
}
}
}
int
mlx5e_tc_act_stats_add_flow(struct mlx5e_tc_act_stats_handle *handle,
struct mlx5e_tc_flow *flow)
{
struct mlx5_fc *curr_counter = NULL;
unsigned long last_cookie = 0;
struct mlx5_flow_attr *attr;
int err;
int i;
if (!flow_flag_test(flow, USE_ACT_STATS))
return 0;
list_for_each_entry(attr, &flow->attrs, list) {
if (attr->counter)
curr_counter = attr->counter;
for (i = 0; i < attr->tc_act_cookies_count; i++) {
/* jump over identical ids (e.g. pedit)*/
if (last_cookie == attr->tc_act_cookies[i])
continue;
err = mlx5e_tc_act_stats_add(handle, attr->tc_act_cookies[i], curr_counter);
if (err)
goto out_err;
last_cookie = attr->tc_act_cookies[i];
}
}
return 0;
out_err:
mlx5e_tc_act_stats_del_flow(handle, flow);
return err;
}
int
mlx5e_tc_act_stats_fill_stats(struct mlx5e_tc_act_stats_handle *handle,
struct flow_offload_action *fl_act)
{
struct rhashtable *ht = &handle->ht;
struct mlx5e_tc_act_stats *item;
struct mlx5e_tc_act_stats key;
u64 pkts, bytes, lastused;
int err = 0;
key.tc_act_cookie = fl_act->cookie;
rcu_read_lock();
item = rhashtable_lookup(ht, &key, act_counters_ht_params);
if (!item) {
rcu_read_unlock();
err = -ENOENT;
goto err_out;
}
mlx5_fc_query_cached_raw(item->counter,
&bytes, &pkts, &lastused);
flow_stats_update(&fl_act->stats,
bytes - item->lastbytes,
pkts - item->lastpackets,
0, lastused, FLOW_ACTION_HW_STATS_DELAYED);
item->lastpackets = pkts;
item->lastbytes = bytes;
rcu_read_unlock();
return 0;
err_out:
return err;
}
|
