]>
Commit | Line | Data |
---|---|---|
413d3347 MZ |
1 | // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB |
2 | /* | |
3 | * Copyright (c) 2019 Mellanox Technologies. All rights reserved. | |
4 | */ | |
5 | #include <rdma/ib_verbs.h> | |
6 | #include <rdma/rdma_counter.h> | |
7 | ||
8 | #include "core_priv.h" | |
9 | #include "restrack.h" | |
10 | ||
11 | #define ALL_AUTO_MODE_MASKS (RDMA_COUNTER_MASK_QP_TYPE) | |
12 | ||
13 | static int __counter_set_mode(struct rdma_counter_mode *curr, | |
14 | enum rdma_nl_counter_mode new_mode, | |
15 | enum rdma_nl_counter_mask new_mask) | |
16 | { | |
17 | if ((new_mode == RDMA_COUNTER_MODE_AUTO) && | |
18 | ((new_mask & (~ALL_AUTO_MODE_MASKS)) || | |
19 | (curr->mode != RDMA_COUNTER_MODE_NONE))) | |
20 | return -EINVAL; | |
21 | ||
22 | curr->mode = new_mode; | |
23 | curr->mask = new_mask; | |
24 | return 0; | |
25 | } | |
26 | ||
27 | /** | |
28 | * rdma_counter_set_auto_mode() - Turn on/off per-port auto mode | |
29 | * | |
1bd8e0a9 MZ |
30 | * When @on is true, the @mask must be set; When @on is false, it goes |
31 | * into manual mode if there's any counter, so that the user is able to | |
32 | * manually access them. | |
413d3347 MZ |
33 | */ |
34 | int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, | |
35 | bool on, enum rdma_nl_counter_mask mask) | |
36 | { | |
37 | struct rdma_port_counter *port_counter; | |
38 | int ret; | |
39 | ||
40 | port_counter = &dev->port_data[port].port_counter; | |
d97de888 MZ |
41 | if (!port_counter->hstats) |
42 | return -EOPNOTSUPP; | |
43 | ||
413d3347 MZ |
44 | mutex_lock(&port_counter->lock); |
45 | if (on) { | |
46 | ret = __counter_set_mode(&port_counter->mode, | |
47 | RDMA_COUNTER_MODE_AUTO, mask); | |
48 | } else { | |
49 | if (port_counter->mode.mode != RDMA_COUNTER_MODE_AUTO) { | |
50 | ret = -EINVAL; | |
51 | goto out; | |
52 | } | |
1bd8e0a9 MZ |
53 | |
54 | if (port_counter->num_counters) | |
55 | ret = __counter_set_mode(&port_counter->mode, | |
56 | RDMA_COUNTER_MODE_MANUAL, 0); | |
57 | else | |
58 | ret = __counter_set_mode(&port_counter->mode, | |
59 | RDMA_COUNTER_MODE_NONE, 0); | |
413d3347 MZ |
60 | } |
61 | ||
62 | out: | |
63 | mutex_unlock(&port_counter->lock); | |
64 | return ret; | |
65 | } | |
66 | ||
99fa331d MZ |
67 | static struct rdma_counter *rdma_counter_alloc(struct ib_device *dev, u8 port, |
68 | enum rdma_nl_counter_mode mode) | |
69 | { | |
1bd8e0a9 | 70 | struct rdma_port_counter *port_counter; |
99fa331d | 71 | struct rdma_counter *counter; |
1bd8e0a9 | 72 | int ret; |
99fa331d | 73 | |
c4ffee7c | 74 | if (!dev->ops.counter_dealloc || !dev->ops.counter_alloc_stats) |
99fa331d MZ |
75 | return NULL; |
76 | ||
77 | counter = kzalloc(sizeof(*counter), GFP_KERNEL); | |
78 | if (!counter) | |
79 | return NULL; | |
80 | ||
81 | counter->device = dev; | |
82 | counter->port = port; | |
83 | counter->res.type = RDMA_RESTRACK_COUNTER; | |
c4ffee7c MZ |
84 | counter->stats = dev->ops.counter_alloc_stats(counter); |
85 | if (!counter->stats) | |
86 | goto err_stats; | |
87 | ||
1bd8e0a9 MZ |
88 | port_counter = &dev->port_data[port].port_counter; |
89 | mutex_lock(&port_counter->lock); | |
90 | if (mode == RDMA_COUNTER_MODE_MANUAL) { | |
91 | ret = __counter_set_mode(&port_counter->mode, | |
92 | RDMA_COUNTER_MODE_MANUAL, 0); | |
93 | if (ret) | |
94 | goto err_mode; | |
95 | } | |
96 | ||
97 | port_counter->num_counters++; | |
98 | mutex_unlock(&port_counter->lock); | |
99 | ||
99fa331d MZ |
100 | counter->mode.mode = mode; |
101 | kref_init(&counter->kref); | |
102 | mutex_init(&counter->lock); | |
103 | ||
104 | return counter; | |
c4ffee7c | 105 | |
1bd8e0a9 MZ |
106 | err_mode: |
107 | mutex_unlock(&port_counter->lock); | |
108 | kfree(counter->stats); | |
c4ffee7c MZ |
109 | err_stats: |
110 | kfree(counter); | |
111 | return NULL; | |
99fa331d MZ |
112 | } |
113 | ||
114 | static void rdma_counter_free(struct rdma_counter *counter) | |
115 | { | |
1bd8e0a9 MZ |
116 | struct rdma_port_counter *port_counter; |
117 | ||
118 | port_counter = &counter->device->port_data[counter->port].port_counter; | |
119 | mutex_lock(&port_counter->lock); | |
120 | port_counter->num_counters--; | |
121 | if (!port_counter->num_counters && | |
122 | (port_counter->mode.mode == RDMA_COUNTER_MODE_MANUAL)) | |
123 | __counter_set_mode(&port_counter->mode, RDMA_COUNTER_MODE_NONE, | |
124 | 0); | |
125 | ||
126 | mutex_unlock(&port_counter->lock); | |
127 | ||
99fa331d | 128 | rdma_restrack_del(&counter->res); |
c4ffee7c | 129 | kfree(counter->stats); |
99fa331d MZ |
130 | kfree(counter); |
131 | } | |
132 | ||
133 | static void auto_mode_init_counter(struct rdma_counter *counter, | |
134 | const struct ib_qp *qp, | |
135 | enum rdma_nl_counter_mask new_mask) | |
136 | { | |
137 | struct auto_mode_param *param = &counter->mode.param; | |
138 | ||
139 | counter->mode.mode = RDMA_COUNTER_MODE_AUTO; | |
140 | counter->mode.mask = new_mask; | |
141 | ||
142 | if (new_mask & RDMA_COUNTER_MASK_QP_TYPE) | |
143 | param->qp_type = qp->qp_type; | |
144 | } | |
145 | ||
146 | static bool auto_mode_match(struct ib_qp *qp, struct rdma_counter *counter, | |
147 | enum rdma_nl_counter_mask auto_mask) | |
148 | { | |
149 | struct auto_mode_param *param = &counter->mode.param; | |
150 | bool match = true; | |
151 | ||
152 | if (rdma_is_kernel_res(&counter->res) != rdma_is_kernel_res(&qp->res)) | |
153 | return false; | |
154 | ||
155 | /* Ensure that counter belong to right PID */ | |
156 | if (!rdma_is_kernel_res(&counter->res) && | |
157 | !rdma_is_kernel_res(&qp->res) && | |
158 | (task_pid_vnr(counter->res.task) != current->pid)) | |
159 | return false; | |
160 | ||
161 | if (auto_mask & RDMA_COUNTER_MASK_QP_TYPE) | |
162 | match &= (param->qp_type == qp->qp_type); | |
163 | ||
164 | return match; | |
165 | } | |
166 | ||
167 | static int __rdma_counter_bind_qp(struct rdma_counter *counter, | |
168 | struct ib_qp *qp) | |
169 | { | |
170 | int ret; | |
171 | ||
172 | if (qp->counter) | |
173 | return -EINVAL; | |
174 | ||
175 | if (!qp->device->ops.counter_bind_qp) | |
176 | return -EOPNOTSUPP; | |
177 | ||
178 | mutex_lock(&counter->lock); | |
179 | ret = qp->device->ops.counter_bind_qp(counter, qp); | |
180 | mutex_unlock(&counter->lock); | |
181 | ||
182 | return ret; | |
183 | } | |
184 | ||
185 | static int __rdma_counter_unbind_qp(struct ib_qp *qp) | |
186 | { | |
187 | struct rdma_counter *counter = qp->counter; | |
188 | int ret; | |
189 | ||
190 | if (!qp->device->ops.counter_unbind_qp) | |
191 | return -EOPNOTSUPP; | |
192 | ||
193 | mutex_lock(&counter->lock); | |
194 | ret = qp->device->ops.counter_unbind_qp(qp); | |
195 | mutex_unlock(&counter->lock); | |
196 | ||
197 | return ret; | |
198 | } | |
199 | ||
f34a55e4 MZ |
200 | static void counter_history_stat_update(const struct rdma_counter *counter) |
201 | { | |
202 | struct ib_device *dev = counter->device; | |
203 | struct rdma_port_counter *port_counter; | |
204 | int i; | |
205 | ||
206 | port_counter = &dev->port_data[counter->port].port_counter; | |
207 | if (!port_counter->hstats) | |
208 | return; | |
209 | ||
210 | for (i = 0; i < counter->stats->num_counters; i++) | |
211 | port_counter->hstats->value[i] += counter->stats->value[i]; | |
212 | } | |
213 | ||
99fa331d MZ |
214 | /** |
215 | * rdma_get_counter_auto_mode - Find the counter that @qp should be bound | |
216 | * with in auto mode | |
217 | * | |
218 | * Return: The counter (with ref-count increased) if found | |
219 | */ | |
220 | static struct rdma_counter *rdma_get_counter_auto_mode(struct ib_qp *qp, | |
221 | u8 port) | |
222 | { | |
223 | struct rdma_port_counter *port_counter; | |
224 | struct rdma_counter *counter = NULL; | |
225 | struct ib_device *dev = qp->device; | |
226 | struct rdma_restrack_entry *res; | |
227 | struct rdma_restrack_root *rt; | |
228 | unsigned long id = 0; | |
229 | ||
230 | port_counter = &dev->port_data[port].port_counter; | |
231 | rt = &dev->res[RDMA_RESTRACK_COUNTER]; | |
232 | xa_lock(&rt->xa); | |
233 | xa_for_each(&rt->xa, id, res) { | |
234 | if (!rdma_is_visible_in_pid_ns(res)) | |
235 | continue; | |
236 | ||
237 | counter = container_of(res, struct rdma_counter, res); | |
238 | if ((counter->device != qp->device) || (counter->port != port)) | |
239 | goto next; | |
240 | ||
241 | if (auto_mode_match(qp, counter, port_counter->mode.mask)) | |
242 | break; | |
243 | next: | |
244 | counter = NULL; | |
245 | } | |
246 | ||
247 | if (counter && !kref_get_unless_zero(&counter->kref)) | |
248 | counter = NULL; | |
249 | ||
250 | xa_unlock(&rt->xa); | |
251 | return counter; | |
252 | } | |
253 | ||
254 | static void rdma_counter_res_add(struct rdma_counter *counter, | |
255 | struct ib_qp *qp) | |
256 | { | |
257 | if (rdma_is_kernel_res(&qp->res)) { | |
258 | rdma_restrack_set_task(&counter->res, qp->res.kern_name); | |
259 | rdma_restrack_kadd(&counter->res); | |
260 | } else { | |
261 | rdma_restrack_attach_task(&counter->res, qp->res.task); | |
262 | rdma_restrack_uadd(&counter->res); | |
263 | } | |
264 | } | |
265 | ||
266 | static void counter_release(struct kref *kref) | |
267 | { | |
268 | struct rdma_counter *counter; | |
269 | ||
270 | counter = container_of(kref, struct rdma_counter, kref); | |
f34a55e4 | 271 | counter_history_stat_update(counter); |
99fa331d MZ |
272 | counter->device->ops.counter_dealloc(counter); |
273 | rdma_counter_free(counter); | |
274 | } | |
275 | ||
276 | /** | |
277 | * rdma_counter_bind_qp_auto - Check and bind the QP to a counter base on | |
278 | * the auto-mode rule | |
279 | */ | |
280 | int rdma_counter_bind_qp_auto(struct ib_qp *qp, u8 port) | |
281 | { | |
282 | struct rdma_port_counter *port_counter; | |
283 | struct ib_device *dev = qp->device; | |
284 | struct rdma_counter *counter; | |
285 | int ret; | |
286 | ||
287 | if (!rdma_is_port_valid(dev, port)) | |
288 | return -EINVAL; | |
289 | ||
290 | port_counter = &dev->port_data[port].port_counter; | |
291 | if (port_counter->mode.mode != RDMA_COUNTER_MODE_AUTO) | |
292 | return 0; | |
293 | ||
294 | counter = rdma_get_counter_auto_mode(qp, port); | |
295 | if (counter) { | |
296 | ret = __rdma_counter_bind_qp(counter, qp); | |
297 | if (ret) { | |
298 | kref_put(&counter->kref, counter_release); | |
299 | return ret; | |
300 | } | |
301 | } else { | |
302 | counter = rdma_counter_alloc(dev, port, RDMA_COUNTER_MODE_AUTO); | |
303 | if (!counter) | |
304 | return -ENOMEM; | |
305 | ||
306 | auto_mode_init_counter(counter, qp, port_counter->mode.mask); | |
307 | ||
308 | ret = __rdma_counter_bind_qp(counter, qp); | |
309 | if (ret) { | |
310 | rdma_counter_free(counter); | |
311 | return ret; | |
312 | } | |
313 | ||
314 | rdma_counter_res_add(counter, qp); | |
315 | } | |
316 | ||
317 | return 0; | |
318 | } | |
319 | ||
320 | /** | |
321 | * rdma_counter_unbind_qp - Unbind a qp from a counter | |
322 | * @force: | |
323 | * true - Decrease the counter ref-count anyway (e.g., qp destroy) | |
324 | */ | |
325 | int rdma_counter_unbind_qp(struct ib_qp *qp, bool force) | |
326 | { | |
327 | struct rdma_counter *counter = qp->counter; | |
328 | int ret; | |
329 | ||
330 | if (!counter) | |
331 | return -EINVAL; | |
332 | ||
333 | ret = __rdma_counter_unbind_qp(qp); | |
334 | if (ret && !force) | |
335 | return ret; | |
336 | ||
337 | kref_put(&counter->kref, counter_release); | |
338 | return 0; | |
339 | } | |
340 | ||
c4ffee7c MZ |
341 | int rdma_counter_query_stats(struct rdma_counter *counter) |
342 | { | |
343 | struct ib_device *dev = counter->device; | |
344 | int ret; | |
345 | ||
346 | if (!dev->ops.counter_update_stats) | |
347 | return -EINVAL; | |
348 | ||
349 | mutex_lock(&counter->lock); | |
350 | ret = dev->ops.counter_update_stats(counter); | |
351 | mutex_unlock(&counter->lock); | |
352 | ||
353 | return ret; | |
354 | } | |
355 | ||
f34a55e4 MZ |
356 | static u64 get_running_counters_hwstat_sum(struct ib_device *dev, |
357 | u8 port, u32 index) | |
358 | { | |
359 | struct rdma_restrack_entry *res; | |
360 | struct rdma_restrack_root *rt; | |
361 | struct rdma_counter *counter; | |
362 | unsigned long id = 0; | |
363 | u64 sum = 0; | |
364 | ||
365 | rt = &dev->res[RDMA_RESTRACK_COUNTER]; | |
366 | xa_lock(&rt->xa); | |
367 | xa_for_each(&rt->xa, id, res) { | |
368 | if (!rdma_restrack_get(res)) | |
369 | continue; | |
370 | ||
371 | xa_unlock(&rt->xa); | |
372 | ||
373 | counter = container_of(res, struct rdma_counter, res); | |
374 | if ((counter->device != dev) || (counter->port != port) || | |
375 | rdma_counter_query_stats(counter)) | |
376 | goto next; | |
377 | ||
378 | sum += counter->stats->value[index]; | |
379 | ||
380 | next: | |
381 | xa_lock(&rt->xa); | |
382 | rdma_restrack_put(res); | |
383 | } | |
384 | ||
385 | xa_unlock(&rt->xa); | |
386 | return sum; | |
387 | } | |
388 | ||
389 | /** | |
390 | * rdma_counter_get_hwstat_value() - Get the sum value of all counters on a | |
391 | * specific port, including the running ones and history data | |
392 | */ | |
393 | u64 rdma_counter_get_hwstat_value(struct ib_device *dev, u8 port, u32 index) | |
394 | { | |
395 | struct rdma_port_counter *port_counter; | |
396 | u64 sum; | |
397 | ||
398 | port_counter = &dev->port_data[port].port_counter; | |
a379d1ce PP |
399 | if (!port_counter->hstats) |
400 | return 0; | |
401 | ||
f34a55e4 MZ |
402 | sum = get_running_counters_hwstat_sum(dev, port, index); |
403 | sum += port_counter->hstats->value[index]; | |
404 | ||
405 | return sum; | |
406 | } | |
407 | ||
1bd8e0a9 MZ |
408 | static struct ib_qp *rdma_counter_get_qp(struct ib_device *dev, u32 qp_num) |
409 | { | |
410 | struct rdma_restrack_entry *res = NULL; | |
411 | struct ib_qp *qp = NULL; | |
412 | ||
413 | res = rdma_restrack_get_byid(dev, RDMA_RESTRACK_QP, qp_num); | |
414 | if (IS_ERR(res)) | |
415 | return NULL; | |
416 | ||
417 | if (!rdma_is_visible_in_pid_ns(res)) | |
418 | goto err; | |
419 | ||
420 | qp = container_of(res, struct ib_qp, res); | |
421 | if (qp->qp_type == IB_QPT_RAW_PACKET && !capable(CAP_NET_RAW)) | |
422 | goto err; | |
423 | ||
424 | return qp; | |
425 | ||
426 | err: | |
427 | rdma_restrack_put(&qp->res); | |
428 | return NULL; | |
429 | } | |
430 | ||
431 | static int rdma_counter_bind_qp_manual(struct rdma_counter *counter, | |
432 | struct ib_qp *qp) | |
433 | { | |
434 | if ((counter->device != qp->device) || (counter->port != qp->port)) | |
435 | return -EINVAL; | |
436 | ||
437 | return __rdma_counter_bind_qp(counter, qp); | |
438 | } | |
439 | ||
440 | static struct rdma_counter *rdma_get_counter_by_id(struct ib_device *dev, | |
441 | u32 counter_id) | |
442 | { | |
443 | struct rdma_restrack_entry *res; | |
444 | struct rdma_counter *counter; | |
445 | ||
446 | res = rdma_restrack_get_byid(dev, RDMA_RESTRACK_COUNTER, counter_id); | |
447 | if (IS_ERR(res)) | |
448 | return NULL; | |
449 | ||
450 | if (!rdma_is_visible_in_pid_ns(res)) { | |
451 | rdma_restrack_put(res); | |
452 | return NULL; | |
453 | } | |
454 | ||
455 | counter = container_of(res, struct rdma_counter, res); | |
456 | kref_get(&counter->kref); | |
457 | rdma_restrack_put(res); | |
458 | ||
459 | return counter; | |
460 | } | |
461 | ||
462 | /** | |
463 | * rdma_counter_bind_qpn() - Bind QP @qp_num to counter @counter_id | |
464 | */ | |
465 | int rdma_counter_bind_qpn(struct ib_device *dev, u8 port, | |
466 | u32 qp_num, u32 counter_id) | |
467 | { | |
468 | struct rdma_counter *counter; | |
469 | struct ib_qp *qp; | |
470 | int ret; | |
471 | ||
472 | qp = rdma_counter_get_qp(dev, qp_num); | |
473 | if (!qp) | |
474 | return -ENOENT; | |
475 | ||
476 | counter = rdma_get_counter_by_id(dev, counter_id); | |
477 | if (!counter) { | |
478 | ret = -ENOENT; | |
479 | goto err; | |
480 | } | |
481 | ||
482 | if (counter->res.task != qp->res.task) { | |
483 | ret = -EINVAL; | |
484 | goto err_task; | |
485 | } | |
486 | ||
487 | ret = rdma_counter_bind_qp_manual(counter, qp); | |
488 | if (ret) | |
489 | goto err_task; | |
490 | ||
491 | rdma_restrack_put(&qp->res); | |
492 | return 0; | |
493 | ||
494 | err_task: | |
495 | kref_put(&counter->kref, counter_release); | |
496 | err: | |
497 | rdma_restrack_put(&qp->res); | |
498 | return ret; | |
499 | } | |
500 | ||
501 | /** | |
502 | * rdma_counter_bind_qpn_alloc() - Alloc a counter and bind QP @qp_num to it | |
503 | * The id of new counter is returned in @counter_id | |
504 | */ | |
505 | int rdma_counter_bind_qpn_alloc(struct ib_device *dev, u8 port, | |
506 | u32 qp_num, u32 *counter_id) | |
507 | { | |
508 | struct rdma_counter *counter; | |
509 | struct ib_qp *qp; | |
510 | int ret; | |
511 | ||
512 | if (!rdma_is_port_valid(dev, port)) | |
513 | return -EINVAL; | |
514 | ||
d97de888 MZ |
515 | if (!dev->port_data[port].port_counter.hstats) |
516 | return -EOPNOTSUPP; | |
517 | ||
1bd8e0a9 MZ |
518 | qp = rdma_counter_get_qp(dev, qp_num); |
519 | if (!qp) | |
520 | return -ENOENT; | |
521 | ||
522 | if (rdma_is_port_valid(dev, qp->port) && (qp->port != port)) { | |
523 | ret = -EINVAL; | |
524 | goto err; | |
525 | } | |
526 | ||
527 | counter = rdma_counter_alloc(dev, port, RDMA_COUNTER_MODE_MANUAL); | |
528 | if (!counter) { | |
529 | ret = -ENOMEM; | |
530 | goto err; | |
531 | } | |
532 | ||
533 | ret = rdma_counter_bind_qp_manual(counter, qp); | |
534 | if (ret) | |
535 | goto err_bind; | |
536 | ||
537 | if (counter_id) | |
538 | *counter_id = counter->id; | |
539 | ||
540 | rdma_counter_res_add(counter, qp); | |
541 | ||
542 | rdma_restrack_put(&qp->res); | |
543 | return ret; | |
544 | ||
545 | err_bind: | |
546 | rdma_counter_free(counter); | |
547 | err: | |
548 | rdma_restrack_put(&qp->res); | |
549 | return ret; | |
550 | } | |
551 | ||
552 | /** | |
553 | * rdma_counter_unbind_qpn() - Unbind QP @qp_num from a counter | |
554 | */ | |
555 | int rdma_counter_unbind_qpn(struct ib_device *dev, u8 port, | |
556 | u32 qp_num, u32 counter_id) | |
557 | { | |
558 | struct rdma_port_counter *port_counter; | |
559 | struct ib_qp *qp; | |
560 | int ret; | |
561 | ||
562 | if (!rdma_is_port_valid(dev, port)) | |
563 | return -EINVAL; | |
564 | ||
565 | qp = rdma_counter_get_qp(dev, qp_num); | |
566 | if (!qp) | |
567 | return -ENOENT; | |
568 | ||
569 | if (rdma_is_port_valid(dev, qp->port) && (qp->port != port)) { | |
570 | ret = -EINVAL; | |
571 | goto out; | |
572 | } | |
573 | ||
574 | port_counter = &dev->port_data[port].port_counter; | |
575 | if (!qp->counter || qp->counter->id != counter_id || | |
576 | port_counter->mode.mode != RDMA_COUNTER_MODE_MANUAL) { | |
577 | ret = -EINVAL; | |
578 | goto out; | |
579 | } | |
580 | ||
581 | ret = rdma_counter_unbind_qp(qp, false); | |
582 | ||
583 | out: | |
584 | rdma_restrack_put(&qp->res); | |
585 | return ret; | |
586 | } | |
587 | ||
83c2c1fc MZ |
588 | int rdma_counter_get_mode(struct ib_device *dev, u8 port, |
589 | enum rdma_nl_counter_mode *mode, | |
590 | enum rdma_nl_counter_mask *mask) | |
591 | { | |
592 | struct rdma_port_counter *port_counter; | |
593 | ||
594 | port_counter = &dev->port_data[port].port_counter; | |
595 | *mode = port_counter->mode.mode; | |
596 | *mask = port_counter->mode.mask; | |
597 | ||
598 | return 0; | |
599 | } | |
600 | ||
413d3347 MZ |
601 | void rdma_counter_init(struct ib_device *dev) |
602 | { | |
603 | struct rdma_port_counter *port_counter; | |
604 | u32 port; | |
605 | ||
d191152f | 606 | if (!dev->port_data) |
413d3347 MZ |
607 | return; |
608 | ||
609 | rdma_for_each_port(dev, port) { | |
610 | port_counter = &dev->port_data[port].port_counter; | |
611 | port_counter->mode.mode = RDMA_COUNTER_MODE_NONE; | |
612 | mutex_init(&port_counter->lock); | |
f34a55e4 | 613 | |
d191152f PP |
614 | if (!dev->ops.alloc_hw_stats) |
615 | continue; | |
616 | ||
f34a55e4 MZ |
617 | port_counter->hstats = dev->ops.alloc_hw_stats(dev, port); |
618 | if (!port_counter->hstats) | |
619 | goto fail; | |
413d3347 | 620 | } |
f34a55e4 MZ |
621 | |
622 | return; | |
623 | ||
624 | fail: | |
625 | rdma_for_each_port(dev, port) { | |
626 | port_counter = &dev->port_data[port].port_counter; | |
627 | kfree(port_counter->hstats); | |
628 | port_counter->hstats = NULL; | |
629 | } | |
630 | ||
631 | return; | |
413d3347 MZ |
632 | } |
633 | ||
634 | void rdma_counter_release(struct ib_device *dev) | |
635 | { | |
f34a55e4 MZ |
636 | struct rdma_port_counter *port_counter; |
637 | u32 port; | |
638 | ||
f34a55e4 MZ |
639 | rdma_for_each_port(dev, port) { |
640 | port_counter = &dev->port_data[port].port_counter; | |
641 | kfree(port_counter->hstats); | |
642 | } | |
413d3347 | 643 | } |