1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 */
6
7#include "devl_internal.h"
8
9/**
10 * struct devlink_resource - devlink resource
11 * @name: name of the resource
12 * @id: id, per devlink instance
13 * @size: size of the resource
14 * @size_new: updated size of the resource, reload is needed
15 * @size_valid: valid in case the total size of the resource is valid
16 * including its children
17 * @parent: parent resource
18 * @size_params: size parameters
19 * @list: parent list
20 * @resource_list: list of child resources
21 * @occ_get: occupancy getter callback
22 * @occ_get_priv: occupancy getter callback priv
23 */
24struct devlink_resource {
25 const char *name;
26 u64 id;
27 u64 size;
28 u64 size_new;
29 bool size_valid;
30 struct devlink_resource *parent;
31 struct devlink_resource_size_params size_params;
32 struct list_head list;
33 struct list_head resource_list;
34 devlink_resource_occ_get_t *occ_get;
35 void *occ_get_priv;
36};
37
38static struct devlink_resource *
39devlink_resource_find(struct devlink *devlink,
40 struct devlink_resource *resource, u64 resource_id)
41{
42 struct list_head *resource_list;
43
44 if (resource)
45 resource_list = &resource->resource_list;
46 else
47 resource_list = &devlink->resource_list;
48
49 list_for_each_entry(resource, resource_list, list) {
50 struct devlink_resource *child_resource;
51
52 if (resource->id == resource_id)
53 return resource;
54
55 child_resource = devlink_resource_find(devlink, resource,
56 resource_id);
57 if (child_resource)
58 return child_resource;
59 }
60 return NULL;
61}
62
63static void
64devlink_resource_validate_children(struct devlink_resource *resource)
65{
66 struct devlink_resource *child_resource;
67 bool size_valid = true;
68 u64 parts_size = 0;
69
70 if (list_empty(head: &resource->resource_list))
71 goto out;
72
73 list_for_each_entry(child_resource, &resource->resource_list, list)
74 parts_size += child_resource->size_new;
75
76 if (parts_size > resource->size_new)
77 size_valid = false;
78out:
79 resource->size_valid = size_valid;
80}
81
82static int
83devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
84 struct netlink_ext_ack *extack)
85{
86 u64 reminder;
87 int err = 0;
88
89 if (size > resource->size_params.size_max) {
90 NL_SET_ERR_MSG(extack, "Size larger than maximum");
91 err = -EINVAL;
92 }
93
94 if (size < resource->size_params.size_min) {
95 NL_SET_ERR_MSG(extack, "Size smaller than minimum");
96 err = -EINVAL;
97 }
98
99 div64_u64_rem(dividend: size, divisor: resource->size_params.size_granularity, remainder: &reminder);
100 if (reminder) {
101 NL_SET_ERR_MSG(extack, "Wrong granularity");
102 err = -EINVAL;
103 }
104
105 return err;
106}
107
108int devlink_nl_resource_set_doit(struct sk_buff *skb, struct genl_info *info)
109{
110 struct devlink *devlink = info->user_ptr[0];
111 struct devlink_resource *resource;
112 u64 resource_id;
113 u64 size;
114 int err;
115
116 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_RESOURCE_ID) ||
117 GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_RESOURCE_SIZE))
118 return -EINVAL;
119 resource_id = nla_get_u64(nla: info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
120
121 resource = devlink_resource_find(devlink, NULL, resource_id);
122 if (!resource)
123 return -EINVAL;
124
125 size = nla_get_u64(nla: info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
126 err = devlink_resource_validate_size(resource, size, extack: info->extack);
127 if (err)
128 return err;
129
130 resource->size_new = size;
131 devlink_resource_validate_children(resource);
132 if (resource->parent)
133 devlink_resource_validate_children(resource: resource->parent);
134 return 0;
135}
136
137static int
138devlink_resource_size_params_put(struct devlink_resource *resource,
139 struct sk_buff *skb)
140{
141 struct devlink_resource_size_params *size_params;
142
143 size_params = &resource->size_params;
144 if (devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
145 val: size_params->size_granularity) ||
146 devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_SIZE_MAX,
147 val: size_params->size_max) ||
148 devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_SIZE_MIN,
149 val: size_params->size_min) ||
150 nla_put_u8(skb, attrtype: DEVLINK_ATTR_RESOURCE_UNIT, value: size_params->unit))
151 return -EMSGSIZE;
152 return 0;
153}
154
155static int devlink_resource_occ_put(struct devlink_resource *resource,
156 struct sk_buff *skb)
157{
158 if (!resource->occ_get)
159 return 0;
160 return devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_OCC,
161 val: resource->occ_get(resource->occ_get_priv));
162}
163
164static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
165 struct devlink_resource *resource)
166{
167 struct devlink_resource *child_resource;
168 struct nlattr *child_resource_attr;
169 struct nlattr *resource_attr;
170
171 resource_attr = nla_nest_start_noflag(skb, attrtype: DEVLINK_ATTR_RESOURCE);
172 if (!resource_attr)
173 return -EMSGSIZE;
174
175 if (nla_put_string(skb, attrtype: DEVLINK_ATTR_RESOURCE_NAME, str: resource->name) ||
176 devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_SIZE, val: resource->size) ||
177 devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_ID, val: resource->id))
178 goto nla_put_failure;
179 if (resource->size != resource->size_new &&
180 devlink_nl_put_u64(msg: skb, attrtype: DEVLINK_ATTR_RESOURCE_SIZE_NEW,
181 val: resource->size_new))
182 goto nla_put_failure;
183 if (devlink_resource_occ_put(resource, skb))
184 goto nla_put_failure;
185 if (devlink_resource_size_params_put(resource, skb))
186 goto nla_put_failure;
187 if (list_empty(head: &resource->resource_list))
188 goto out;
189
190 if (nla_put_u8(skb, attrtype: DEVLINK_ATTR_RESOURCE_SIZE_VALID,
191 value: resource->size_valid))
192 goto nla_put_failure;
193
194 child_resource_attr = nla_nest_start_noflag(skb,
195 attrtype: DEVLINK_ATTR_RESOURCE_LIST);
196 if (!child_resource_attr)
197 goto nla_put_failure;
198
199 list_for_each_entry(child_resource, &resource->resource_list, list) {
200 if (devlink_resource_put(devlink, skb, resource: child_resource))
201 goto resource_put_failure;
202 }
203
204 nla_nest_end(skb, start: child_resource_attr);
205out:
206 nla_nest_end(skb, start: resource_attr);
207 return 0;
208
209resource_put_failure:
210 nla_nest_cancel(skb, start: child_resource_attr);
211nla_put_failure:
212 nla_nest_cancel(skb, start: resource_attr);
213 return -EMSGSIZE;
214}
215
216static int devlink_resource_fill(struct genl_info *info,
217 enum devlink_command cmd, int flags)
218{
219 struct devlink *devlink = info->user_ptr[0];
220 struct devlink_resource *resource;
221 struct nlattr *resources_attr;
222 struct sk_buff *skb = NULL;
223 struct nlmsghdr *nlh;
224 bool incomplete;
225 void *hdr;
226 int i;
227 int err;
228
229 resource = list_first_entry(&devlink->resource_list,
230 struct devlink_resource, list);
231start_again:
232 err = devlink_nl_msg_reply_and_new(msg: &skb, info);
233 if (err)
234 return err;
235
236 hdr = genlmsg_put(skb, portid: info->snd_portid, seq: info->snd_seq,
237 family: &devlink_nl_family, NLM_F_MULTI, cmd);
238 if (!hdr) {
239 nlmsg_free(skb);
240 return -EMSGSIZE;
241 }
242
243 if (devlink_nl_put_handle(msg: skb, devlink))
244 goto nla_put_failure;
245
246 resources_attr = nla_nest_start_noflag(skb,
247 attrtype: DEVLINK_ATTR_RESOURCE_LIST);
248 if (!resources_attr)
249 goto nla_put_failure;
250
251 incomplete = false;
252 i = 0;
253 list_for_each_entry_from(resource, &devlink->resource_list, list) {
254 err = devlink_resource_put(devlink, skb, resource);
255 if (err) {
256 if (!i)
257 goto err_resource_put;
258 incomplete = true;
259 break;
260 }
261 i++;
262 }
263 nla_nest_end(skb, start: resources_attr);
264 genlmsg_end(skb, hdr);
265 if (incomplete)
266 goto start_again;
267send_done:
268 nlh = nlmsg_put(skb, portid: info->snd_portid, seq: info->snd_seq,
269 NLMSG_DONE, payload: 0, flags: flags | NLM_F_MULTI);
270 if (!nlh) {
271 err = devlink_nl_msg_reply_and_new(msg: &skb, info);
272 if (err)
273 return err;
274 goto send_done;
275 }
276 return genlmsg_reply(skb, info);
277
278nla_put_failure:
279 err = -EMSGSIZE;
280err_resource_put:
281 nlmsg_free(skb);
282 return err;
283}
284
285int devlink_nl_resource_dump_doit(struct sk_buff *skb, struct genl_info *info)
286{
287 struct devlink *devlink = info->user_ptr[0];
288
289 if (list_empty(head: &devlink->resource_list))
290 return -EOPNOTSUPP;
291
292 return devlink_resource_fill(info, cmd: DEVLINK_CMD_RESOURCE_DUMP, flags: 0);
293}
294
295int devlink_resources_validate(struct devlink *devlink,
296 struct devlink_resource *resource,
297 struct genl_info *info)
298{
299 struct list_head *resource_list;
300 int err = 0;
301
302 if (resource)
303 resource_list = &resource->resource_list;
304 else
305 resource_list = &devlink->resource_list;
306
307 list_for_each_entry(resource, resource_list, list) {
308 if (!resource->size_valid)
309 return -EINVAL;
310 err = devlink_resources_validate(devlink, resource, info);
311 if (err)
312 return err;
313 }
314 return err;
315}
316
317/**
318 * devl_resource_register - devlink resource register
319 *
320 * @devlink: devlink
321 * @resource_name: resource's name
322 * @resource_size: resource's size
323 * @resource_id: resource's id
324 * @parent_resource_id: resource's parent id
325 * @size_params: size parameters
326 *
327 * Generic resources should reuse the same names across drivers.
328 * Please see the generic resources list at:
329 * Documentation/networking/devlink/devlink-resource.rst
330 */
331int devl_resource_register(struct devlink *devlink,
332 const char *resource_name,
333 u64 resource_size,
334 u64 resource_id,
335 u64 parent_resource_id,
336 const struct devlink_resource_size_params *size_params)
337{
338 struct devlink_resource *resource;
339 struct list_head *resource_list;
340 bool top_hierarchy;
341
342 lockdep_assert_held(&devlink->lock);
343
344 top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
345
346 resource = devlink_resource_find(devlink, NULL, resource_id);
347 if (resource)
348 return -EEXIST;
349
350 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
351 if (!resource)
352 return -ENOMEM;
353
354 if (top_hierarchy) {
355 resource_list = &devlink->resource_list;
356 } else {
357 struct devlink_resource *parent_resource;
358
359 parent_resource = devlink_resource_find(devlink, NULL,
360 resource_id: parent_resource_id);
361 if (parent_resource) {
362 resource_list = &parent_resource->resource_list;
363 resource->parent = parent_resource;
364 } else {
365 kfree(objp: resource);
366 return -EINVAL;
367 }
368 }
369
370 resource->name = resource_name;
371 resource->size = resource_size;
372 resource->size_new = resource_size;
373 resource->id = resource_id;
374 resource->size_valid = true;
375 memcpy(&resource->size_params, size_params,
376 sizeof(resource->size_params));
377 INIT_LIST_HEAD(list: &resource->resource_list);
378 list_add_tail(new: &resource->list, head: resource_list);
379
380 return 0;
381}
382EXPORT_SYMBOL_GPL(devl_resource_register);
383
384static void devlink_resource_unregister(struct devlink *devlink,
385 struct devlink_resource *resource)
386{
387 struct devlink_resource *tmp, *child_resource;
388
389 list_for_each_entry_safe(child_resource, tmp, &resource->resource_list,
390 list) {
391 devlink_resource_unregister(devlink, resource: child_resource);
392 list_del(entry: &child_resource->list);
393 kfree(objp: child_resource);
394 }
395}
396
397/**
398 * devl_resources_unregister - free all resources
399 *
400 * @devlink: devlink
401 */
402void devl_resources_unregister(struct devlink *devlink)
403{
404 struct devlink_resource *tmp, *child_resource;
405
406 lockdep_assert_held(&devlink->lock);
407
408 list_for_each_entry_safe(child_resource, tmp, &devlink->resource_list,
409 list) {
410 devlink_resource_unregister(devlink, resource: child_resource);
411 list_del(entry: &child_resource->list);
412 kfree(objp: child_resource);
413 }
414}
415EXPORT_SYMBOL_GPL(devl_resources_unregister);
416
417/**
418 * devlink_resources_unregister - free all resources
419 *
420 * @devlink: devlink
421 *
422 * Context: Takes and release devlink->lock <mutex>.
423 */
424void devlink_resources_unregister(struct devlink *devlink)
425{
426 devl_lock(devlink);
427 devl_resources_unregister(devlink);
428 devl_unlock(devlink);
429}
430EXPORT_SYMBOL_GPL(devlink_resources_unregister);
431
432/**
433 * devl_resource_size_get - get and update size
434 *
435 * @devlink: devlink
436 * @resource_id: the requested resource id
437 * @p_resource_size: ptr to update
438 */
439int devl_resource_size_get(struct devlink *devlink,
440 u64 resource_id,
441 u64 *p_resource_size)
442{
443 struct devlink_resource *resource;
444
445 lockdep_assert_held(&devlink->lock);
446
447 resource = devlink_resource_find(devlink, NULL, resource_id);
448 if (!resource)
449 return -EINVAL;
450 *p_resource_size = resource->size_new;
451 resource->size = resource->size_new;
452 return 0;
453}
454EXPORT_SYMBOL_GPL(devl_resource_size_get);
455
456/**
457 * devl_resource_occ_get_register - register occupancy getter
458 *
459 * @devlink: devlink
460 * @resource_id: resource id
461 * @occ_get: occupancy getter callback
462 * @occ_get_priv: occupancy getter callback priv
463 */
464void devl_resource_occ_get_register(struct devlink *devlink,
465 u64 resource_id,
466 devlink_resource_occ_get_t *occ_get,
467 void *occ_get_priv)
468{
469 struct devlink_resource *resource;
470
471 lockdep_assert_held(&devlink->lock);
472
473 resource = devlink_resource_find(devlink, NULL, resource_id);
474 if (WARN_ON(!resource))
475 return;
476 WARN_ON(resource->occ_get);
477
478 resource->occ_get = occ_get;
479 resource->occ_get_priv = occ_get_priv;
480}
481EXPORT_SYMBOL_GPL(devl_resource_occ_get_register);
482
483/**
484 * devl_resource_occ_get_unregister - unregister occupancy getter
485 *
486 * @devlink: devlink
487 * @resource_id: resource id
488 */
489void devl_resource_occ_get_unregister(struct devlink *devlink,
490 u64 resource_id)
491{
492 struct devlink_resource *resource;
493
494 lockdep_assert_held(&devlink->lock);
495
496 resource = devlink_resource_find(devlink, NULL, resource_id);
497 if (WARN_ON(!resource))
498 return;
499 WARN_ON(!resource->occ_get);
500
501 resource->occ_get = NULL;
502 resource->occ_get_priv = NULL;
503}
504EXPORT_SYMBOL_GPL(devl_resource_occ_get_unregister);
505

source code of linux/net/devlink/resource.c

Morty Proxy This is a proxified and sanitized view of the page, visit original site.