xref: /openbmc/linux/net/devlink/resource.c (revision d171c85d) 
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  */
24 struct 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 
38 static struct devlink_resource *
39 devlink_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 
63 static void
64 devlink_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(&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;
78 out:
79 	resource->size_valid = size_valid;
80 }
81 
82 static int
83 devlink_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(size, resource->size_params.size_granularity, &reminder);
100 	if (reminder) {
101 		NL_SET_ERR_MSG(extack, "Wrong granularity");
102 		err = -EINVAL;
103 	}
104 
105 	return err;
106 }
107 
108 int devlink_nl_cmd_resource_set(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(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(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
126 	err = devlink_resource_validate_size(resource, size, 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->parent);
134 	return 0;
135 }
136 
137 static int
138 devlink_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 (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
145 			      size_params->size_granularity, DEVLINK_ATTR_PAD) ||
146 	    nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
147 			      size_params->size_max, DEVLINK_ATTR_PAD) ||
148 	    nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
149 			      size_params->size_min, DEVLINK_ATTR_PAD) ||
150 	    nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
151 		return -EMSGSIZE;
152 	return 0;
153 }
154 
155 static 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 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
161 				 resource->occ_get(resource->occ_get_priv),
162 				 DEVLINK_ATTR_PAD);
163 }
164 
165 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
166 				struct devlink_resource *resource)
167 {
168 	struct devlink_resource *child_resource;
169 	struct nlattr *child_resource_attr;
170 	struct nlattr *resource_attr;
171 
172 	resource_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_RESOURCE);
173 	if (!resource_attr)
174 		return -EMSGSIZE;
175 
176 	if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
177 	    nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
178 			      DEVLINK_ATTR_PAD) ||
179 	    nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
180 			      DEVLINK_ATTR_PAD))
181 		goto nla_put_failure;
182 	if (resource->size != resource->size_new &&
183 	    nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
184 			      resource->size_new, DEVLINK_ATTR_PAD))
185 		goto nla_put_failure;
186 	if (devlink_resource_occ_put(resource, skb))
187 		goto nla_put_failure;
188 	if (devlink_resource_size_params_put(resource, skb))
189 		goto nla_put_failure;
190 	if (list_empty(&resource->resource_list))
191 		goto out;
192 
193 	if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
194 		       resource->size_valid))
195 		goto nla_put_failure;
196 
197 	child_resource_attr = nla_nest_start_noflag(skb,
198 						    DEVLINK_ATTR_RESOURCE_LIST);
199 	if (!child_resource_attr)
200 		goto nla_put_failure;
201 
202 	list_for_each_entry(child_resource, &resource->resource_list, list) {
203 		if (devlink_resource_put(devlink, skb, child_resource))
204 			goto resource_put_failure;
205 	}
206 
207 	nla_nest_end(skb, child_resource_attr);
208 out:
209 	nla_nest_end(skb, resource_attr);
210 	return 0;
211 
212 resource_put_failure:
213 	nla_nest_cancel(skb, child_resource_attr);
214 nla_put_failure:
215 	nla_nest_cancel(skb, resource_attr);
216 	return -EMSGSIZE;
217 }
218 
219 static int devlink_resource_fill(struct genl_info *info,
220 				 enum devlink_command cmd, int flags)
221 {
222 	struct devlink *devlink = info->user_ptr[0];
223 	struct devlink_resource *resource;
224 	struct nlattr *resources_attr;
225 	struct sk_buff *skb = NULL;
226 	struct nlmsghdr *nlh;
227 	bool incomplete;
228 	void *hdr;
229 	int i;
230 	int err;
231 
232 	resource = list_first_entry(&devlink->resource_list,
233 				    struct devlink_resource, list);
234 start_again:
235 	err = devlink_nl_msg_reply_and_new(&skb, info);
236 	if (err)
237 		return err;
238 
239 	hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
240 			  &devlink_nl_family, NLM_F_MULTI, cmd);
241 	if (!hdr) {
242 		nlmsg_free(skb);
243 		return -EMSGSIZE;
244 	}
245 
246 	if (devlink_nl_put_handle(skb, devlink))
247 		goto nla_put_failure;
248 
249 	resources_attr = nla_nest_start_noflag(skb,
250 					       DEVLINK_ATTR_RESOURCE_LIST);
251 	if (!resources_attr)
252 		goto nla_put_failure;
253 
254 	incomplete = false;
255 	i = 0;
256 	list_for_each_entry_from(resource, &devlink->resource_list, list) {
257 		err = devlink_resource_put(devlink, skb, resource);
258 		if (err) {
259 			if (!i)
260 				goto err_resource_put;
261 			incomplete = true;
262 			break;
263 		}
264 		i++;
265 	}
266 	nla_nest_end(skb, resources_attr);
267 	genlmsg_end(skb, hdr);
268 	if (incomplete)
269 		goto start_again;
270 send_done:
271 	nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
272 			NLMSG_DONE, 0, flags | NLM_F_MULTI);
273 	if (!nlh) {
274 		err = devlink_nl_msg_reply_and_new(&skb, info);
275 		if (err)
276 			return err;
277 		goto send_done;
278 	}
279 	return genlmsg_reply(skb, info);
280 
281 nla_put_failure:
282 	err = -EMSGSIZE;
283 err_resource_put:
284 	nlmsg_free(skb);
285 	return err;
286 }
287 
288 int devlink_nl_cmd_resource_dump(struct sk_buff *skb, struct genl_info *info)
289 {
290 	struct devlink *devlink = info->user_ptr[0];
291 
292 	if (list_empty(&devlink->resource_list))
293 		return -EOPNOTSUPP;
294 
295 	return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
296 }
297 
298 int devlink_resources_validate(struct devlink *devlink,
299 			       struct devlink_resource *resource,
300 			       struct genl_info *info)
301 {
302 	struct list_head *resource_list;
303 	int err = 0;
304 
305 	if (resource)
306 		resource_list = &resource->resource_list;
307 	else
308 		resource_list = &devlink->resource_list;
309 
310 	list_for_each_entry(resource, resource_list, list) {
311 		if (!resource->size_valid)
312 			return -EINVAL;
313 		err = devlink_resources_validate(devlink, resource, info);
314 		if (err)
315 			return err;
316 	}
317 	return err;
318 }
319 
320 /**
321  * devl_resource_register - devlink resource register
322  *
323  * @devlink: devlink
324  * @resource_name: resource's name
325  * @resource_size: resource's size
326  * @resource_id: resource's id
327  * @parent_resource_id: resource's parent id
328  * @size_params: size parameters
329  *
330  * Generic resources should reuse the same names across drivers.
331  * Please see the generic resources list at:
332  * Documentation/networking/devlink/devlink-resource.rst
333  */
334 int devl_resource_register(struct devlink *devlink,
335 			   const char *resource_name,
336 			   u64 resource_size,
337 			   u64 resource_id,
338 			   u64 parent_resource_id,
339 			   const struct devlink_resource_size_params *size_params)
340 {
341 	struct devlink_resource *resource;
342 	struct list_head *resource_list;
343 	bool top_hierarchy;
344 
345 	lockdep_assert_held(&devlink->lock);
346 
347 	top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
348 
349 	resource = devlink_resource_find(devlink, NULL, resource_id);
350 	if (resource)
351 		return -EINVAL;
352 
353 	resource = kzalloc(sizeof(*resource), GFP_KERNEL);
354 	if (!resource)
355 		return -ENOMEM;
356 
357 	if (top_hierarchy) {
358 		resource_list = &devlink->resource_list;
359 	} else {
360 		struct devlink_resource *parent_resource;
361 
362 		parent_resource = devlink_resource_find(devlink, NULL,
363 							parent_resource_id);
364 		if (parent_resource) {
365 			resource_list = &parent_resource->resource_list;
366 			resource->parent = parent_resource;
367 		} else {
368 			kfree(resource);
369 			return -EINVAL;
370 		}
371 	}
372 
373 	resource->name = resource_name;
374 	resource->size = resource_size;
375 	resource->size_new = resource_size;
376 	resource->id = resource_id;
377 	resource->size_valid = true;
378 	memcpy(&resource->size_params, size_params,
379 	       sizeof(resource->size_params));
380 	INIT_LIST_HEAD(&resource->resource_list);
381 	list_add_tail(&resource->list, resource_list);
382 
383 	return 0;
384 }
385 EXPORT_SYMBOL_GPL(devl_resource_register);
386 
387 /**
388  *	devlink_resource_register - devlink resource register
389  *
390  *	@devlink: devlink
391  *	@resource_name: resource's name
392  *	@resource_size: resource's size
393  *	@resource_id: resource's id
394  *	@parent_resource_id: resource's parent id
395  *	@size_params: size parameters
396  *
397  *	Generic resources should reuse the same names across drivers.
398  *	Please see the generic resources list at:
399  *	Documentation/networking/devlink/devlink-resource.rst
400  *
401  *	Context: Takes and release devlink->lock <mutex>.
402  */
403 int devlink_resource_register(struct devlink *devlink,
404 			      const char *resource_name,
405 			      u64 resource_size,
406 			      u64 resource_id,
407 			      u64 parent_resource_id,
408 			      const struct devlink_resource_size_params *size_params)
409 {
410 	int err;
411 
412 	devl_lock(devlink);
413 	err = devl_resource_register(devlink, resource_name, resource_size,
414 				     resource_id, parent_resource_id, size_params);
415 	devl_unlock(devlink);
416 	return err;
417 }
418 EXPORT_SYMBOL_GPL(devlink_resource_register);
419 
420 static void devlink_resource_unregister(struct devlink *devlink,
421 					struct devlink_resource *resource)
422 {
423 	struct devlink_resource *tmp, *child_resource;
424 
425 	list_for_each_entry_safe(child_resource, tmp, &resource->resource_list,
426 				 list) {
427 		devlink_resource_unregister(devlink, child_resource);
428 		list_del(&child_resource->list);
429 		kfree(child_resource);
430 	}
431 }
432 
433 /**
434  * devl_resources_unregister - free all resources
435  *
436  * @devlink: devlink
437  */
438 void devl_resources_unregister(struct devlink *devlink)
439 {
440 	struct devlink_resource *tmp, *child_resource;
441 
442 	lockdep_assert_held(&devlink->lock);
443 
444 	list_for_each_entry_safe(child_resource, tmp, &devlink->resource_list,
445 				 list) {
446 		devlink_resource_unregister(devlink, child_resource);
447 		list_del(&child_resource->list);
448 		kfree(child_resource);
449 	}
450 }
451 EXPORT_SYMBOL_GPL(devl_resources_unregister);
452 
453 /**
454  *	devlink_resources_unregister - free all resources
455  *
456  *	@devlink: devlink
457  *
458  *	Context: Takes and release devlink->lock <mutex>.
459  */
460 void devlink_resources_unregister(struct devlink *devlink)
461 {
462 	devl_lock(devlink);
463 	devl_resources_unregister(devlink);
464 	devl_unlock(devlink);
465 }
466 EXPORT_SYMBOL_GPL(devlink_resources_unregister);
467 
468 /**
469  * devl_resource_size_get - get and update size
470  *
471  * @devlink: devlink
472  * @resource_id: the requested resource id
473  * @p_resource_size: ptr to update
474  */
475 int devl_resource_size_get(struct devlink *devlink,
476 			   u64 resource_id,
477 			   u64 *p_resource_size)
478 {
479 	struct devlink_resource *resource;
480 
481 	lockdep_assert_held(&devlink->lock);
482 
483 	resource = devlink_resource_find(devlink, NULL, resource_id);
484 	if (!resource)
485 		return -EINVAL;
486 	*p_resource_size = resource->size_new;
487 	resource->size = resource->size_new;
488 	return 0;
489 }
490 EXPORT_SYMBOL_GPL(devl_resource_size_get);
491 
492 /**
493  * devl_resource_occ_get_register - register occupancy getter
494  *
495  * @devlink: devlink
496  * @resource_id: resource id
497  * @occ_get: occupancy getter callback
498  * @occ_get_priv: occupancy getter callback priv
499  */
500 void devl_resource_occ_get_register(struct devlink *devlink,
501 				    u64 resource_id,
502 				    devlink_resource_occ_get_t *occ_get,
503 				    void *occ_get_priv)
504 {
505 	struct devlink_resource *resource;
506 
507 	lockdep_assert_held(&devlink->lock);
508 
509 	resource = devlink_resource_find(devlink, NULL, resource_id);
510 	if (WARN_ON(!resource))
511 		return;
512 	WARN_ON(resource->occ_get);
513 
514 	resource->occ_get = occ_get;
515 	resource->occ_get_priv = occ_get_priv;
516 }
517 EXPORT_SYMBOL_GPL(devl_resource_occ_get_register);
518 
519 /**
520  *	devlink_resource_occ_get_register - register occupancy getter
521  *
522  *	@devlink: devlink
523  *	@resource_id: resource id
524  *	@occ_get: occupancy getter callback
525  *	@occ_get_priv: occupancy getter callback priv
526  *
527  *	Context: Takes and release devlink->lock <mutex>.
528  */
529 void devlink_resource_occ_get_register(struct devlink *devlink,
530 				       u64 resource_id,
531 				       devlink_resource_occ_get_t *occ_get,
532 				       void *occ_get_priv)
533 {
534 	devl_lock(devlink);
535 	devl_resource_occ_get_register(devlink, resource_id,
536 				       occ_get, occ_get_priv);
537 	devl_unlock(devlink);
538 }
539 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_register);
540 
541 /**
542  * devl_resource_occ_get_unregister - unregister occupancy getter
543  *
544  * @devlink: devlink
545  * @resource_id: resource id
546  */
547 void devl_resource_occ_get_unregister(struct devlink *devlink,
548 				      u64 resource_id)
549 {
550 	struct devlink_resource *resource;
551 
552 	lockdep_assert_held(&devlink->lock);
553 
554 	resource = devlink_resource_find(devlink, NULL, resource_id);
555 	if (WARN_ON(!resource))
556 		return;
557 	WARN_ON(!resource->occ_get);
558 
559 	resource->occ_get = NULL;
560 	resource->occ_get_priv = NULL;
561 }
562 EXPORT_SYMBOL_GPL(devl_resource_occ_get_unregister);
563 
564 /**
565  *	devlink_resource_occ_get_unregister - unregister occupancy getter
566  *
567  *	@devlink: devlink
568  *	@resource_id: resource id
569  *
570  *	Context: Takes and release devlink->lock <mutex>.
571  */
572 void devlink_resource_occ_get_unregister(struct devlink *devlink,
573 					 u64 resource_id)
574 {
575 	devl_lock(devlink);
576 	devl_resource_occ_get_unregister(devlink, resource_id);
577 	devl_unlock(devlink);
578 }
579 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_unregister);
580