devtools/cocci: create safer version of strlcpy script
[dpdk.git] / lib / librte_ethdev / rte_tm.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2017 Intel Corporation
3  */
4
5 #include <stdint.h>
6
7 #include <rte_errno.h>
8 #include "rte_ethdev.h"
9 #include "rte_tm_driver.h"
10 #include "rte_tm.h"
11
12 /* Get generic traffic manager operations structure from a port. */
13 const struct rte_tm_ops *
14 rte_tm_ops_get(uint16_t port_id, struct rte_tm_error *error)
15 {
16         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
17         const struct rte_tm_ops *ops;
18
19         if (!rte_eth_dev_is_valid_port(port_id)) {
20                 rte_tm_error_set(error,
21                         ENODEV,
22                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
23                         NULL,
24                         rte_strerror(ENODEV));
25                 return NULL;
26         }
27
28         if ((dev->dev_ops->tm_ops_get == NULL) ||
29                 (dev->dev_ops->tm_ops_get(dev, &ops) != 0) ||
30                 (ops == NULL)) {
31                 rte_tm_error_set(error,
32                         ENOSYS,
33                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
34                         NULL,
35                         rte_strerror(ENOSYS));
36                 return NULL;
37         }
38
39         return ops;
40 }
41
42 #define RTE_TM_FUNC(port_id, func)                              \
43 ({                                                      \
44         const struct rte_tm_ops *ops =                  \
45                 rte_tm_ops_get(port_id, error);         \
46         if (ops == NULL)                                        \
47                 return -rte_errno;                      \
48                                                         \
49         if (ops->func == NULL)                          \
50                 return -rte_tm_error_set(error,         \
51                         ENOSYS,                         \
52                         RTE_TM_ERROR_TYPE_UNSPECIFIED,  \
53                         NULL,                           \
54                         rte_strerror(ENOSYS));          \
55                                                         \
56         ops->func;                                      \
57 })
58
59 /* Get number of leaf nodes */
60 int
61 rte_tm_get_number_of_leaf_nodes(uint16_t port_id,
62         uint32_t *n_leaf_nodes,
63         struct rte_tm_error *error)
64 {
65         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
66         const struct rte_tm_ops *ops =
67                 rte_tm_ops_get(port_id, error);
68
69         if (ops == NULL)
70                 return -rte_errno;
71
72         if (n_leaf_nodes == NULL) {
73                 rte_tm_error_set(error,
74                         EINVAL,
75                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
76                         NULL,
77                         rte_strerror(EINVAL));
78                 return -rte_errno;
79         }
80
81         *n_leaf_nodes = dev->data->nb_tx_queues;
82         return 0;
83 }
84
85 /* Check node type (leaf or non-leaf) */
86 int
87 rte_tm_node_type_get(uint16_t port_id,
88         uint32_t node_id,
89         int *is_leaf,
90         struct rte_tm_error *error)
91 {
92         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
93         return RTE_TM_FUNC(port_id, node_type_get)(dev,
94                 node_id, is_leaf, error);
95 }
96
97 /* Get capabilities */
98 int rte_tm_capabilities_get(uint16_t port_id,
99         struct rte_tm_capabilities *cap,
100         struct rte_tm_error *error)
101 {
102         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
103         return RTE_TM_FUNC(port_id, capabilities_get)(dev,
104                 cap, error);
105 }
106
107 /* Get level capabilities */
108 int rte_tm_level_capabilities_get(uint16_t port_id,
109         uint32_t level_id,
110         struct rte_tm_level_capabilities *cap,
111         struct rte_tm_error *error)
112 {
113         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
114         return RTE_TM_FUNC(port_id, level_capabilities_get)(dev,
115                 level_id, cap, error);
116 }
117
118 /* Get node capabilities */
119 int rte_tm_node_capabilities_get(uint16_t port_id,
120         uint32_t node_id,
121         struct rte_tm_node_capabilities *cap,
122         struct rte_tm_error *error)
123 {
124         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
125         return RTE_TM_FUNC(port_id, node_capabilities_get)(dev,
126                 node_id, cap, error);
127 }
128
129 /* Add WRED profile */
130 int rte_tm_wred_profile_add(uint16_t port_id,
131         uint32_t wred_profile_id,
132         struct rte_tm_wred_params *profile,
133         struct rte_tm_error *error)
134 {
135         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
136         return RTE_TM_FUNC(port_id, wred_profile_add)(dev,
137                 wred_profile_id, profile, error);
138 }
139
140 /* Delete WRED profile */
141 int rte_tm_wred_profile_delete(uint16_t port_id,
142         uint32_t wred_profile_id,
143         struct rte_tm_error *error)
144 {
145         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
146         return RTE_TM_FUNC(port_id, wred_profile_delete)(dev,
147                 wred_profile_id, error);
148 }
149
150 /* Add/update shared WRED context */
151 int rte_tm_shared_wred_context_add_update(uint16_t port_id,
152         uint32_t shared_wred_context_id,
153         uint32_t wred_profile_id,
154         struct rte_tm_error *error)
155 {
156         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
157         return RTE_TM_FUNC(port_id, shared_wred_context_add_update)(dev,
158                 shared_wred_context_id, wred_profile_id, error);
159 }
160
161 /* Delete shared WRED context */
162 int rte_tm_shared_wred_context_delete(uint16_t port_id,
163         uint32_t shared_wred_context_id,
164         struct rte_tm_error *error)
165 {
166         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
167         return RTE_TM_FUNC(port_id, shared_wred_context_delete)(dev,
168                 shared_wred_context_id, error);
169 }
170
171 /* Add shaper profile */
172 int rte_tm_shaper_profile_add(uint16_t port_id,
173         uint32_t shaper_profile_id,
174         struct rte_tm_shaper_params *profile,
175         struct rte_tm_error *error)
176 {
177         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
178         return RTE_TM_FUNC(port_id, shaper_profile_add)(dev,
179                 shaper_profile_id, profile, error);
180 }
181
182 /* Delete WRED profile */
183 int rte_tm_shaper_profile_delete(uint16_t port_id,
184         uint32_t shaper_profile_id,
185         struct rte_tm_error *error)
186 {
187         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
188         return RTE_TM_FUNC(port_id, shaper_profile_delete)(dev,
189                 shaper_profile_id, error);
190 }
191
192 /* Add shared shaper */
193 int rte_tm_shared_shaper_add_update(uint16_t port_id,
194         uint32_t shared_shaper_id,
195         uint32_t shaper_profile_id,
196         struct rte_tm_error *error)
197 {
198         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
199         return RTE_TM_FUNC(port_id, shared_shaper_add_update)(dev,
200                 shared_shaper_id, shaper_profile_id, error);
201 }
202
203 /* Delete shared shaper */
204 int rte_tm_shared_shaper_delete(uint16_t port_id,
205         uint32_t shared_shaper_id,
206         struct rte_tm_error *error)
207 {
208         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
209         return RTE_TM_FUNC(port_id, shared_shaper_delete)(dev,
210                 shared_shaper_id, error);
211 }
212
213 /* Add node to port traffic manager hierarchy */
214 int rte_tm_node_add(uint16_t port_id,
215         uint32_t node_id,
216         uint32_t parent_node_id,
217         uint32_t priority,
218         uint32_t weight,
219         uint32_t level_id,
220         struct rte_tm_node_params *params,
221         struct rte_tm_error *error)
222 {
223         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
224         return RTE_TM_FUNC(port_id, node_add)(dev,
225                 node_id, parent_node_id, priority, weight, level_id,
226                 params, error);
227 }
228
229 /* Delete node from traffic manager hierarchy */
230 int rte_tm_node_delete(uint16_t port_id,
231         uint32_t node_id,
232         struct rte_tm_error *error)
233 {
234         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
235         return RTE_TM_FUNC(port_id, node_delete)(dev,
236                 node_id, error);
237 }
238
239 /* Suspend node */
240 int rte_tm_node_suspend(uint16_t port_id,
241         uint32_t node_id,
242         struct rte_tm_error *error)
243 {
244         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
245         return RTE_TM_FUNC(port_id, node_suspend)(dev,
246                 node_id, error);
247 }
248
249 /* Resume node */
250 int rte_tm_node_resume(uint16_t port_id,
251         uint32_t node_id,
252         struct rte_tm_error *error)
253 {
254         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
255         return RTE_TM_FUNC(port_id, node_resume)(dev,
256                 node_id, error);
257 }
258
259 /* Commit the initial port traffic manager hierarchy */
260 int rte_tm_hierarchy_commit(uint16_t port_id,
261         int clear_on_fail,
262         struct rte_tm_error *error)
263 {
264         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
265         return RTE_TM_FUNC(port_id, hierarchy_commit)(dev,
266                 clear_on_fail, error);
267 }
268
269 /* Update node parent  */
270 int rte_tm_node_parent_update(uint16_t port_id,
271         uint32_t node_id,
272         uint32_t parent_node_id,
273         uint32_t priority,
274         uint32_t weight,
275         struct rte_tm_error *error)
276 {
277         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
278         return RTE_TM_FUNC(port_id, node_parent_update)(dev,
279                 node_id, parent_node_id, priority, weight, error);
280 }
281
282 /* Update node private shaper */
283 int rte_tm_node_shaper_update(uint16_t port_id,
284         uint32_t node_id,
285         uint32_t shaper_profile_id,
286         struct rte_tm_error *error)
287 {
288         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
289         return RTE_TM_FUNC(port_id, node_shaper_update)(dev,
290                 node_id, shaper_profile_id, error);
291 }
292
293 /* Update node shared shapers */
294 int rte_tm_node_shared_shaper_update(uint16_t port_id,
295         uint32_t node_id,
296         uint32_t shared_shaper_id,
297         int add,
298         struct rte_tm_error *error)
299 {
300         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
301         return RTE_TM_FUNC(port_id, node_shared_shaper_update)(dev,
302                 node_id, shared_shaper_id, add, error);
303 }
304
305 /* Update node stats */
306 int rte_tm_node_stats_update(uint16_t port_id,
307         uint32_t node_id,
308         uint64_t stats_mask,
309         struct rte_tm_error *error)
310 {
311         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
312         return RTE_TM_FUNC(port_id, node_stats_update)(dev,
313                 node_id, stats_mask, error);
314 }
315
316 /* Update WFQ weight mode */
317 int rte_tm_node_wfq_weight_mode_update(uint16_t port_id,
318         uint32_t node_id,
319         int *wfq_weight_mode,
320         uint32_t n_sp_priorities,
321         struct rte_tm_error *error)
322 {
323         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
324         return RTE_TM_FUNC(port_id, node_wfq_weight_mode_update)(dev,
325                 node_id, wfq_weight_mode, n_sp_priorities, error);
326 }
327
328 /* Update node congestion management mode */
329 int rte_tm_node_cman_update(uint16_t port_id,
330         uint32_t node_id,
331         enum rte_tm_cman_mode cman,
332         struct rte_tm_error *error)
333 {
334         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
335         return RTE_TM_FUNC(port_id, node_cman_update)(dev,
336                 node_id, cman, error);
337 }
338
339 /* Update node private WRED context */
340 int rte_tm_node_wred_context_update(uint16_t port_id,
341         uint32_t node_id,
342         uint32_t wred_profile_id,
343         struct rte_tm_error *error)
344 {
345         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
346         return RTE_TM_FUNC(port_id, node_wred_context_update)(dev,
347                 node_id, wred_profile_id, error);
348 }
349
350 /* Update node shared WRED context */
351 int rte_tm_node_shared_wred_context_update(uint16_t port_id,
352         uint32_t node_id,
353         uint32_t shared_wred_context_id,
354         int add,
355         struct rte_tm_error *error)
356 {
357         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
358         return RTE_TM_FUNC(port_id, node_shared_wred_context_update)(dev,
359                 node_id, shared_wred_context_id, add, error);
360 }
361
362 /* Read and/or clear stats counters for specific node */
363 int rte_tm_node_stats_read(uint16_t port_id,
364         uint32_t node_id,
365         struct rte_tm_node_stats *stats,
366         uint64_t *stats_mask,
367         int clear,
368         struct rte_tm_error *error)
369 {
370         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
371         return RTE_TM_FUNC(port_id, node_stats_read)(dev,
372                 node_id, stats, stats_mask, clear, error);
373 }
374
375 /* Packet marking - VLAN DEI */
376 int rte_tm_mark_vlan_dei(uint16_t port_id,
377         int mark_green,
378         int mark_yellow,
379         int mark_red,
380         struct rte_tm_error *error)
381 {
382         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
383         return RTE_TM_FUNC(port_id, mark_vlan_dei)(dev,
384                 mark_green, mark_yellow, mark_red, error);
385 }
386
387 /* Packet marking - IPv4/IPv6 ECN */
388 int rte_tm_mark_ip_ecn(uint16_t port_id,
389         int mark_green,
390         int mark_yellow,
391         int mark_red,
392         struct rte_tm_error *error)
393 {
394         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
395         return RTE_TM_FUNC(port_id, mark_ip_ecn)(dev,
396                 mark_green, mark_yellow, mark_red, error);
397 }
398
399 /* Packet marking - IPv4/IPv6 DSCP */
400 int rte_tm_mark_ip_dscp(uint16_t port_id,
401         int mark_green,
402         int mark_yellow,
403         int mark_red,
404         struct rte_tm_error *error)
405 {
406         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
407         return RTE_TM_FUNC(port_id, mark_ip_dscp)(dev,
408                 mark_green, mark_yellow, mark_red, error);
409 }