net/mlx5: Add new list to store deleted flow counters
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / fs_counters.c
1 /*
2  * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32
33 #include <linux/mlx5/driver.h>
34 #include <linux/mlx5/fs.h>
35 #include <linux/rbtree.h>
36 #include "mlx5_core.h"
37 #include "fs_core.h"
38 #include "fs_cmd.h"
39
40 #define MLX5_FC_STATS_PERIOD msecs_to_jiffies(1000)
41 /* Max number of counters to query in bulk read is 32K */
42 #define MLX5_SW_MAX_COUNTERS_BULK BIT(15)
43
44 /* locking scheme:
45  *
46  * It is the responsibility of the user to prevent concurrent calls or bad
47  * ordering to mlx5_fc_create(), mlx5_fc_destroy() and accessing a reference
48  * to struct mlx5_fc.
49  * e.g en_tc.c is protected by RTNL lock of its caller, and will never call a
50  * dump (access to struct mlx5_fc) after a counter is destroyed.
51  *
52  * access to counter list:
53  * - create (user context)
54  *   - mlx5_fc_create() only adds to an addlist to be used by
55  *     mlx5_fc_stats_query_work(). addlist is a lockless single linked list
56  *     that doesn't require any additional synchronization when adding single
57  *     node.
58  *   - spawn thread to do the actual destroy
59  *
60  * - destroy (user context)
61  *   - add a counter to lockless dellist
62  *   - spawn thread to do the actual del
63  *
64  * - dump (user context)
65  *   user should not call dump after destroy
66  *
67  * - query (single thread workqueue context)
68  *   destroy/dump - no conflict (see destroy)
69  *   query/dump - packets and bytes might be inconsistent (since update is not
70  *                atomic)
71  *   query/create - no conflict (see create)
72  *   since every create/destroy spawn the work, only after necessary time has
73  *   elapsed, the thread will actually query the hardware.
74  */
75
76 static void mlx5_fc_stats_insert(struct rb_root *root, struct mlx5_fc *counter)
77 {
78         struct rb_node **new = &root->rb_node;
79         struct rb_node *parent = NULL;
80
81         while (*new) {
82                 struct mlx5_fc *this = rb_entry(*new, struct mlx5_fc, node);
83                 int result = counter->id - this->id;
84
85                 parent = *new;
86                 if (result < 0)
87                         new = &((*new)->rb_left);
88                 else
89                         new = &((*new)->rb_right);
90         }
91
92         /* Add new node and rebalance tree. */
93         rb_link_node(&counter->node, parent, new);
94         rb_insert_color(&counter->node, root);
95 }
96
97 /* The function returns the last node that was queried so the caller
98  * function can continue calling it till all counters are queried.
99  */
100 static struct rb_node *mlx5_fc_stats_query(struct mlx5_core_dev *dev,
101                                            struct mlx5_fc *first,
102                                            u32 last_id)
103 {
104         struct mlx5_cmd_fc_bulk *b;
105         struct rb_node *node = NULL;
106         u32 afirst_id;
107         int num;
108         int err;
109
110         int max_bulk = min_t(int, MLX5_SW_MAX_COUNTERS_BULK,
111                              (1 << MLX5_CAP_GEN(dev, log_max_flow_counter_bulk)));
112
113         /* first id must be aligned to 4 when using bulk query */
114         afirst_id = first->id & ~0x3;
115
116         /* number of counters to query inc. the last counter */
117         num = ALIGN(last_id - afirst_id + 1, 4);
118         if (num > max_bulk) {
119                 num = max_bulk;
120                 last_id = afirst_id + num - 1;
121         }
122
123         b = mlx5_cmd_fc_bulk_alloc(dev, afirst_id, num);
124         if (!b) {
125                 mlx5_core_err(dev, "Error allocating resources for bulk query\n");
126                 return NULL;
127         }
128
129         err = mlx5_cmd_fc_bulk_query(dev, b);
130         if (err) {
131                 mlx5_core_err(dev, "Error doing bulk query: %d\n", err);
132                 goto out;
133         }
134
135         for (node = &first->node; node; node = rb_next(node)) {
136                 struct mlx5_fc *counter = rb_entry(node, struct mlx5_fc, node);
137                 struct mlx5_fc_cache *c = &counter->cache;
138                 u64 packets;
139                 u64 bytes;
140
141                 if (counter->id > last_id)
142                         break;
143
144                 mlx5_cmd_fc_bulk_get(dev, b,
145                                      counter->id, &packets, &bytes);
146
147                 if (c->packets == packets)
148                         continue;
149
150                 c->packets = packets;
151                 c->bytes = bytes;
152                 c->lastuse = jiffies;
153         }
154
155 out:
156         mlx5_cmd_fc_bulk_free(b);
157
158         return node;
159 }
160
161 static void mlx5_free_fc(struct mlx5_core_dev *dev,
162                          struct mlx5_fc *counter)
163 {
164         mlx5_cmd_fc_free(dev, counter->id);
165         kfree(counter);
166 }
167
168 static void mlx5_fc_stats_work(struct work_struct *work)
169 {
170         struct mlx5_core_dev *dev = container_of(work, struct mlx5_core_dev,
171                                                  priv.fc_stats.work.work);
172         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
173         struct llist_node *tmplist = llist_del_all(&fc_stats->addlist);
174         struct mlx5_fc *counter = NULL, *last = NULL, *tmp;
175         unsigned long now = jiffies;
176         struct rb_node *node;
177
178         if (tmplist || !RB_EMPTY_ROOT(&fc_stats->counters))
179                 queue_delayed_work(fc_stats->wq, &fc_stats->work,
180                                    fc_stats->sampling_interval);
181
182         llist_for_each_entry(counter, tmplist, addlist)
183                 mlx5_fc_stats_insert(&fc_stats->counters, counter);
184
185         tmplist = llist_del_all(&fc_stats->dellist);
186         llist_for_each_entry_safe(counter, tmp, tmplist, dellist) {
187                 rb_erase(&counter->node, &fc_stats->counters);
188
189                 mlx5_free_fc(dev, counter);
190         }
191
192         node = rb_last(&fc_stats->counters);
193         if (time_before(now, fc_stats->next_query) || !node)
194                 return;
195         last = rb_entry(node, struct mlx5_fc, node);
196
197         node = rb_first(&fc_stats->counters);
198         while (node) {
199                 counter = rb_entry(node, struct mlx5_fc, node);
200
201                 node = mlx5_fc_stats_query(dev, counter, last->id);
202         }
203
204         fc_stats->next_query = now + fc_stats->sampling_interval;
205 }
206
207 struct mlx5_fc *mlx5_fc_create(struct mlx5_core_dev *dev, bool aging)
208 {
209         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
210         struct mlx5_fc *counter;
211         int err;
212
213         counter = kzalloc(sizeof(*counter), GFP_KERNEL);
214         if (!counter)
215                 return ERR_PTR(-ENOMEM);
216
217         err = mlx5_cmd_fc_alloc(dev, &counter->id);
218         if (err)
219                 goto err_out;
220
221         if (aging) {
222                 counter->cache.lastuse = jiffies;
223                 counter->aging = true;
224
225                 llist_add(&counter->addlist, &fc_stats->addlist);
226
227                 mod_delayed_work(fc_stats->wq, &fc_stats->work, 0);
228         }
229
230         return counter;
231
232 err_out:
233         kfree(counter);
234
235         return ERR_PTR(err);
236 }
237 EXPORT_SYMBOL(mlx5_fc_create);
238
239 void mlx5_fc_destroy(struct mlx5_core_dev *dev, struct mlx5_fc *counter)
240 {
241         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
242
243         if (!counter)
244                 return;
245
246         if (counter->aging) {
247                 llist_add(&counter->dellist, &fc_stats->dellist);
248                 mod_delayed_work(fc_stats->wq, &fc_stats->work, 0);
249                 return;
250         }
251
252         mlx5_free_fc(dev, counter);
253 }
254 EXPORT_SYMBOL(mlx5_fc_destroy);
255
256 int mlx5_init_fc_stats(struct mlx5_core_dev *dev)
257 {
258         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
259
260         fc_stats->counters = RB_ROOT;
261         init_llist_head(&fc_stats->addlist);
262         init_llist_head(&fc_stats->dellist);
263
264         fc_stats->wq = create_singlethread_workqueue("mlx5_fc");
265         if (!fc_stats->wq)
266                 return -ENOMEM;
267
268         fc_stats->sampling_interval = MLX5_FC_STATS_PERIOD;
269         INIT_DELAYED_WORK(&fc_stats->work, mlx5_fc_stats_work);
270
271         return 0;
272 }
273
274 void mlx5_cleanup_fc_stats(struct mlx5_core_dev *dev)
275 {
276         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
277         struct llist_node *tmplist;
278         struct mlx5_fc *counter;
279         struct mlx5_fc *tmp;
280         struct rb_node *node;
281
282         cancel_delayed_work_sync(&dev->priv.fc_stats.work);
283         destroy_workqueue(dev->priv.fc_stats.wq);
284         dev->priv.fc_stats.wq = NULL;
285
286         tmplist = llist_del_all(&fc_stats->addlist);
287         llist_for_each_entry_safe(counter, tmp, tmplist, addlist)
288                 mlx5_free_fc(dev, counter);
289
290         node = rb_first(&fc_stats->counters);
291         while (node) {
292                 counter = rb_entry(node, struct mlx5_fc, node);
293
294                 node = rb_next(node);
295
296                 rb_erase(&counter->node, &fc_stats->counters);
297
298                 mlx5_free_fc(dev, counter);
299         }
300 }
301
302 int mlx5_fc_query(struct mlx5_core_dev *dev, struct mlx5_fc *counter,
303                   u64 *packets, u64 *bytes)
304 {
305         return mlx5_cmd_fc_query(dev, counter->id, packets, bytes);
306 }
307 EXPORT_SYMBOL(mlx5_fc_query);
308
309 void mlx5_fc_query_cached(struct mlx5_fc *counter,
310                           u64 *bytes, u64 *packets, u64 *lastuse)
311 {
312         struct mlx5_fc_cache c;
313
314         c = counter->cache;
315
316         *bytes = c.bytes - counter->lastbytes;
317         *packets = c.packets - counter->lastpackets;
318         *lastuse = c.lastuse;
319
320         counter->lastbytes = c.bytes;
321         counter->lastpackets = c.packets;
322 }
323
324 void mlx5_fc_queue_stats_work(struct mlx5_core_dev *dev,
325                               struct delayed_work *dwork,
326                               unsigned long delay)
327 {
328         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
329
330         queue_delayed_work(fc_stats->wq, dwork, delay);
331 }
332
333 void mlx5_fc_update_sampling_interval(struct mlx5_core_dev *dev,
334                                       unsigned long interval)
335 {
336         struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats;
337
338         fc_stats->sampling_interval = min_t(unsigned long, interval,
339                                             fc_stats->sampling_interval);
340 }