xref: /linux/net/devlink/linecard.c (revision 7fbcd195e2b8cc952e4aeaeb50867b798040314c) 
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 struct devlink_linecard {
10 	struct list_head list;
11 	struct devlink *devlink;
12 	unsigned int index;
13 	const struct devlink_linecard_ops *ops;
14 	void *priv;
15 	enum devlink_linecard_state state;
16 	struct mutex state_lock; /* Protects state */
17 	const char *type;
18 	struct devlink_linecard_type *types;
19 	unsigned int types_count;
20 	u32 rel_index;
21 };
22 
23 unsigned int devlink_linecard_index(struct devlink_linecard *linecard)
24 {
25 	return linecard->index;
26 }
27 
28 static struct devlink_linecard *
29 devlink_linecard_get_by_index(struct devlink *devlink,
30 			      unsigned int linecard_index)
31 {
32 	struct devlink_linecard *devlink_linecard;
33 
34 	list_for_each_entry(devlink_linecard, &devlink->linecard_list, list) {
35 		if (devlink_linecard->index == linecard_index)
36 			return devlink_linecard;
37 	}
38 	return NULL;
39 }
40 
41 static bool devlink_linecard_index_exists(struct devlink *devlink,
42 					  unsigned int linecard_index)
43 {
44 	return devlink_linecard_get_by_index(devlink, linecard_index);
45 }
46 
47 static struct devlink_linecard *
48 devlink_linecard_get_from_attrs(struct devlink *devlink, struct nlattr **attrs)
49 {
50 	if (attrs[DEVLINK_ATTR_LINECARD_INDEX]) {
51 		u32 linecard_index = nla_get_u32(attrs[DEVLINK_ATTR_LINECARD_INDEX]);
52 		struct devlink_linecard *linecard;
53 
54 		linecard = devlink_linecard_get_by_index(devlink, linecard_index);
55 		if (!linecard)
56 			return ERR_PTR(-ENODEV);
57 		return linecard;
58 	}
59 	return ERR_PTR(-EINVAL);
60 }
61 
62 static struct devlink_linecard *
63 devlink_linecard_get_from_info(struct devlink *devlink, struct genl_info *info)
64 {
65 	return devlink_linecard_get_from_attrs(devlink, info->attrs);
66 }
67 
68 struct devlink_linecard_type {
69 	const char *type;
70 	const void *priv;
71 };
72 
73 static int devlink_nl_linecard_fill(struct sk_buff *msg,
74 				    struct devlink *devlink,
75 				    struct devlink_linecard *linecard,
76 				    enum devlink_command cmd, u32 portid,
77 				    u32 seq, int flags,
78 				    struct netlink_ext_ack *extack)
79 {
80 	struct devlink_linecard_type *linecard_type;
81 	struct nlattr *attr;
82 	void *hdr;
83 	int i;
84 
85 	hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
86 	if (!hdr)
87 		return -EMSGSIZE;
88 
89 	if (devlink_nl_put_handle(msg, devlink))
90 		goto nla_put_failure;
91 	if (nla_put_u32(msg, DEVLINK_ATTR_LINECARD_INDEX, linecard->index))
92 		goto nla_put_failure;
93 	if (nla_put_u8(msg, DEVLINK_ATTR_LINECARD_STATE, linecard->state))
94 		goto nla_put_failure;
95 	if (linecard->type &&
96 	    nla_put_string(msg, DEVLINK_ATTR_LINECARD_TYPE, linecard->type))
97 		goto nla_put_failure;
98 
99 	if (linecard->types_count) {
100 		attr = nla_nest_start(msg,
101 				      DEVLINK_ATTR_LINECARD_SUPPORTED_TYPES);
102 		if (!attr)
103 			goto nla_put_failure;
104 		for (i = 0; i < linecard->types_count; i++) {
105 			linecard_type = &linecard->types[i];
106 			if (nla_put_string(msg, DEVLINK_ATTR_LINECARD_TYPE,
107 					   linecard_type->type)) {
108 				nla_nest_cancel(msg, attr);
109 				goto nla_put_failure;
110 			}
111 		}
112 		nla_nest_end(msg, attr);
113 	}
114 
115 	if (devlink_rel_devlink_handle_put(msg, devlink,
116 					   linecard->rel_index,
117 					   DEVLINK_ATTR_NESTED_DEVLINK,
118 					   NULL))
119 		goto nla_put_failure;
120 
121 	genlmsg_end(msg, hdr);
122 	return 0;
123 
124 nla_put_failure:
125 	genlmsg_cancel(msg, hdr);
126 	return -EMSGSIZE;
127 }
128 
129 static void devlink_linecard_notify(struct devlink_linecard *linecard,
130 				    enum devlink_command cmd)
131 {
132 	struct devlink *devlink = linecard->devlink;
133 	struct sk_buff *msg;
134 	int err;
135 
136 	WARN_ON(cmd != DEVLINK_CMD_LINECARD_NEW &&
137 		cmd != DEVLINK_CMD_LINECARD_DEL);
138 
139 	if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
140 		return;
141 
142 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
143 	if (!msg)
144 		return;
145 
146 	err = devlink_nl_linecard_fill(msg, devlink, linecard, cmd, 0, 0, 0,
147 				       NULL);
148 	if (err) {
149 		nlmsg_free(msg);
150 		return;
151 	}
152 
153 	genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
154 				msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
155 }
156 
157 void devlink_linecards_notify_register(struct devlink *devlink)
158 {
159 	struct devlink_linecard *linecard;
160 
161 	list_for_each_entry(linecard, &devlink->linecard_list, list)
162 		devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
163 }
164 
165 void devlink_linecards_notify_unregister(struct devlink *devlink)
166 {
167 	struct devlink_linecard *linecard;
168 
169 	list_for_each_entry_reverse(linecard, &devlink->linecard_list, list)
170 		devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_DEL);
171 }
172 
173 int devlink_nl_linecard_get_doit(struct sk_buff *skb, struct genl_info *info)
174 {
175 	struct devlink *devlink = info->user_ptr[0];
176 	struct devlink_linecard *linecard;
177 	struct sk_buff *msg;
178 	int err;
179 
180 	linecard = devlink_linecard_get_from_info(devlink, info);
181 	if (IS_ERR(linecard))
182 		return PTR_ERR(linecard);
183 
184 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
185 	if (!msg)
186 		return -ENOMEM;
187 
188 	mutex_lock(&linecard->state_lock);
189 	err = devlink_nl_linecard_fill(msg, devlink, linecard,
190 				       DEVLINK_CMD_LINECARD_NEW,
191 				       info->snd_portid, info->snd_seq, 0,
192 				       info->extack);
193 	mutex_unlock(&linecard->state_lock);
194 	if (err) {
195 		nlmsg_free(msg);
196 		return err;
197 	}
198 
199 	return genlmsg_reply(msg, info);
200 }
201 
202 static int devlink_nl_linecard_get_dump_one(struct sk_buff *msg,
203 					    struct devlink *devlink,
204 					    struct netlink_callback *cb,
205 					    int flags)
206 {
207 	struct devlink_nl_dump_state *state = devlink_dump_state(cb);
208 	struct devlink_linecard *linecard;
209 	int idx = 0;
210 	int err = 0;
211 
212 	list_for_each_entry(linecard, &devlink->linecard_list, list) {
213 		if (idx < state->idx) {
214 			idx++;
215 			continue;
216 		}
217 		mutex_lock(&linecard->state_lock);
218 		err = devlink_nl_linecard_fill(msg, devlink, linecard,
219 					       DEVLINK_CMD_LINECARD_NEW,
220 					       NETLINK_CB(cb->skb).portid,
221 					       cb->nlh->nlmsg_seq, flags,
222 					       cb->extack);
223 		mutex_unlock(&linecard->state_lock);
224 		if (err) {
225 			state->idx = idx;
226 			break;
227 		}
228 		idx++;
229 	}
230 
231 	return err;
232 }
233 
234 int devlink_nl_linecard_get_dumpit(struct sk_buff *skb,
235 				   struct netlink_callback *cb)
236 {
237 	return devlink_nl_dumpit(skb, cb, devlink_nl_linecard_get_dump_one);
238 }
239 
240 static struct devlink_linecard_type *
241 devlink_linecard_type_lookup(struct devlink_linecard *linecard,
242 			     const char *type)
243 {
244 	struct devlink_linecard_type *linecard_type;
245 	int i;
246 
247 	for (i = 0; i < linecard->types_count; i++) {
248 		linecard_type = &linecard->types[i];
249 		if (!strcmp(type, linecard_type->type))
250 			return linecard_type;
251 	}
252 	return NULL;
253 }
254 
255 static int devlink_linecard_type_set(struct devlink_linecard *linecard,
256 				     const char *type,
257 				     struct netlink_ext_ack *extack)
258 {
259 	const struct devlink_linecard_ops *ops = linecard->ops;
260 	struct devlink_linecard_type *linecard_type;
261 	int err;
262 
263 	mutex_lock(&linecard->state_lock);
264 	if (linecard->state == DEVLINK_LINECARD_STATE_PROVISIONING) {
265 		NL_SET_ERR_MSG(extack, "Line card is currently being provisioned");
266 		err = -EBUSY;
267 		goto out;
268 	}
269 	if (linecard->state == DEVLINK_LINECARD_STATE_UNPROVISIONING) {
270 		NL_SET_ERR_MSG(extack, "Line card is currently being unprovisioned");
271 		err = -EBUSY;
272 		goto out;
273 	}
274 
275 	linecard_type = devlink_linecard_type_lookup(linecard, type);
276 	if (!linecard_type) {
277 		NL_SET_ERR_MSG(extack, "Unsupported line card type provided");
278 		err = -EINVAL;
279 		goto out;
280 	}
281 
282 	if (linecard->state != DEVLINK_LINECARD_STATE_UNPROVISIONED &&
283 	    linecard->state != DEVLINK_LINECARD_STATE_PROVISIONING_FAILED) {
284 		NL_SET_ERR_MSG(extack, "Line card already provisioned");
285 		err = -EBUSY;
286 		/* Check if the line card is provisioned in the same
287 		 * way the user asks. In case it is, make the operation
288 		 * to return success.
289 		 */
290 		if (ops->same_provision &&
291 		    ops->same_provision(linecard, linecard->priv,
292 					linecard_type->type,
293 					linecard_type->priv))
294 			err = 0;
295 		goto out;
296 	}
297 
298 	linecard->state = DEVLINK_LINECARD_STATE_PROVISIONING;
299 	linecard->type = linecard_type->type;
300 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
301 	mutex_unlock(&linecard->state_lock);
302 	err = ops->provision(linecard, linecard->priv, linecard_type->type,
303 			     linecard_type->priv, extack);
304 	if (err) {
305 		/* Provisioning failed. Assume the linecard is unprovisioned
306 		 * for future operations.
307 		 */
308 		mutex_lock(&linecard->state_lock);
309 		linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
310 		linecard->type = NULL;
311 		devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
312 		mutex_unlock(&linecard->state_lock);
313 	}
314 	return err;
315 
316 out:
317 	mutex_unlock(&linecard->state_lock);
318 	return err;
319 }
320 
321 static int devlink_linecard_type_unset(struct devlink_linecard *linecard,
322 				       struct netlink_ext_ack *extack)
323 {
324 	int err;
325 
326 	mutex_lock(&linecard->state_lock);
327 	if (linecard->state == DEVLINK_LINECARD_STATE_PROVISIONING) {
328 		NL_SET_ERR_MSG(extack, "Line card is currently being provisioned");
329 		err = -EBUSY;
330 		goto out;
331 	}
332 	if (linecard->state == DEVLINK_LINECARD_STATE_UNPROVISIONING) {
333 		NL_SET_ERR_MSG(extack, "Line card is currently being unprovisioned");
334 		err = -EBUSY;
335 		goto out;
336 	}
337 	if (linecard->state == DEVLINK_LINECARD_STATE_PROVISIONING_FAILED) {
338 		linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
339 		linecard->type = NULL;
340 		devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
341 		err = 0;
342 		goto out;
343 	}
344 
345 	if (linecard->state == DEVLINK_LINECARD_STATE_UNPROVISIONED) {
346 		NL_SET_ERR_MSG(extack, "Line card is not provisioned");
347 		err = 0;
348 		goto out;
349 	}
350 	linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONING;
351 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
352 	mutex_unlock(&linecard->state_lock);
353 	err = linecard->ops->unprovision(linecard, linecard->priv,
354 					 extack);
355 	if (err) {
356 		/* Unprovisioning failed. Assume the linecard is unprovisioned
357 		 * for future operations.
358 		 */
359 		mutex_lock(&linecard->state_lock);
360 		linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
361 		linecard->type = NULL;
362 		devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
363 		mutex_unlock(&linecard->state_lock);
364 	}
365 	return err;
366 
367 out:
368 	mutex_unlock(&linecard->state_lock);
369 	return err;
370 }
371 
372 int devlink_nl_linecard_set_doit(struct sk_buff *skb, struct genl_info *info)
373 {
374 	struct netlink_ext_ack *extack = info->extack;
375 	struct devlink *devlink = info->user_ptr[0];
376 	struct devlink_linecard *linecard;
377 	int err;
378 
379 	linecard = devlink_linecard_get_from_info(devlink, info);
380 	if (IS_ERR(linecard))
381 		return PTR_ERR(linecard);
382 
383 	if (info->attrs[DEVLINK_ATTR_LINECARD_TYPE]) {
384 		const char *type;
385 
386 		type = nla_data(info->attrs[DEVLINK_ATTR_LINECARD_TYPE]);
387 		if (strcmp(type, "")) {
388 			err = devlink_linecard_type_set(linecard, type, extack);
389 			if (err)
390 				return err;
391 		} else {
392 			err = devlink_linecard_type_unset(linecard, extack);
393 			if (err)
394 				return err;
395 		}
396 	}
397 
398 	return 0;
399 }
400 
401 static int devlink_linecard_types_init(struct devlink_linecard *linecard)
402 {
403 	struct devlink_linecard_type *linecard_type;
404 	unsigned int count;
405 	int i;
406 
407 	count = linecard->ops->types_count(linecard, linecard->priv);
408 	linecard->types = kmalloc_array(count, sizeof(*linecard_type),
409 					GFP_KERNEL);
410 	if (!linecard->types)
411 		return -ENOMEM;
412 	linecard->types_count = count;
413 
414 	for (i = 0; i < count; i++) {
415 		linecard_type = &linecard->types[i];
416 		linecard->ops->types_get(linecard, linecard->priv, i,
417 					 &linecard_type->type,
418 					 &linecard_type->priv);
419 	}
420 	return 0;
421 }
422 
423 static void devlink_linecard_types_fini(struct devlink_linecard *linecard)
424 {
425 	kfree(linecard->types);
426 }
427 
428 /**
429  *	devl_linecard_create - Create devlink linecard
430  *
431  *	@devlink: devlink
432  *	@linecard_index: driver-specific numerical identifier of the linecard
433  *	@ops: linecards ops
434  *	@priv: user priv pointer
435  *
436  *	Create devlink linecard instance with provided linecard index.
437  *	Caller can use any indexing, even hw-related one.
438  *
439  *	Return: Line card structure or an ERR_PTR() encoded error code.
440  */
441 struct devlink_linecard *
442 devl_linecard_create(struct devlink *devlink, unsigned int linecard_index,
443 		     const struct devlink_linecard_ops *ops, void *priv)
444 {
445 	struct devlink_linecard *linecard;
446 	int err;
447 
448 	if (WARN_ON(!ops || !ops->provision || !ops->unprovision ||
449 		    !ops->types_count || !ops->types_get))
450 		return ERR_PTR(-EINVAL);
451 
452 	if (devlink_linecard_index_exists(devlink, linecard_index))
453 		return ERR_PTR(-EEXIST);
454 
455 	linecard = kzalloc(sizeof(*linecard), GFP_KERNEL);
456 	if (!linecard)
457 		return ERR_PTR(-ENOMEM);
458 
459 	linecard->devlink = devlink;
460 	linecard->index = linecard_index;
461 	linecard->ops = ops;
462 	linecard->priv = priv;
463 	linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
464 	mutex_init(&linecard->state_lock);
465 
466 	err = devlink_linecard_types_init(linecard);
467 	if (err) {
468 		mutex_destroy(&linecard->state_lock);
469 		kfree(linecard);
470 		return ERR_PTR(err);
471 	}
472 
473 	list_add_tail(&linecard->list, &devlink->linecard_list);
474 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
475 	return linecard;
476 }
477 EXPORT_SYMBOL_GPL(devl_linecard_create);
478 
479 /**
480  *	devl_linecard_destroy - Destroy devlink linecard
481  *
482  *	@linecard: devlink linecard
483  */
484 void devl_linecard_destroy(struct devlink_linecard *linecard)
485 {
486 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_DEL);
487 	list_del(&linecard->list);
488 	devlink_linecard_types_fini(linecard);
489 	mutex_destroy(&linecard->state_lock);
490 	kfree(linecard);
491 }
492 EXPORT_SYMBOL_GPL(devl_linecard_destroy);
493 
494 /**
495  *	devlink_linecard_provision_set - Set provisioning on linecard
496  *
497  *	@linecard: devlink linecard
498  *	@type: linecard type
499  *
500  *	This is either called directly from the provision() op call or
501  *	as a result of the provision() op call asynchronously.
502  */
503 void devlink_linecard_provision_set(struct devlink_linecard *linecard,
504 				    const char *type)
505 {
506 	mutex_lock(&linecard->state_lock);
507 	WARN_ON(linecard->type && strcmp(linecard->type, type));
508 	linecard->state = DEVLINK_LINECARD_STATE_PROVISIONED;
509 	linecard->type = type;
510 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
511 	mutex_unlock(&linecard->state_lock);
512 }
513 EXPORT_SYMBOL_GPL(devlink_linecard_provision_set);
514 
515 /**
516  *	devlink_linecard_provision_clear - Clear provisioning on linecard
517  *
518  *	@linecard: devlink linecard
519  *
520  *	This is either called directly from the unprovision() op call or
521  *	as a result of the unprovision() op call asynchronously.
522  */
523 void devlink_linecard_provision_clear(struct devlink_linecard *linecard)
524 {
525 	mutex_lock(&linecard->state_lock);
526 	linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
527 	linecard->type = NULL;
528 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
529 	mutex_unlock(&linecard->state_lock);
530 }
531 EXPORT_SYMBOL_GPL(devlink_linecard_provision_clear);
532 
533 /**
534  *	devlink_linecard_provision_fail - Fail provisioning on linecard
535  *
536  *	@linecard: devlink linecard
537  *
538  *	This is either called directly from the provision() op call or
539  *	as a result of the provision() op call asynchronously.
540  */
541 void devlink_linecard_provision_fail(struct devlink_linecard *linecard)
542 {
543 	mutex_lock(&linecard->state_lock);
544 	linecard->state = DEVLINK_LINECARD_STATE_PROVISIONING_FAILED;
545 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
546 	mutex_unlock(&linecard->state_lock);
547 }
548 EXPORT_SYMBOL_GPL(devlink_linecard_provision_fail);
549 
550 /**
551  *	devlink_linecard_activate - Set linecard active
552  *
553  *	@linecard: devlink linecard
554  */
555 void devlink_linecard_activate(struct devlink_linecard *linecard)
556 {
557 	mutex_lock(&linecard->state_lock);
558 	WARN_ON(linecard->state != DEVLINK_LINECARD_STATE_PROVISIONED);
559 	linecard->state = DEVLINK_LINECARD_STATE_ACTIVE;
560 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
561 	mutex_unlock(&linecard->state_lock);
562 }
563 EXPORT_SYMBOL_GPL(devlink_linecard_activate);
564 
565 /**
566  *	devlink_linecard_deactivate - Set linecard inactive
567  *
568  *	@linecard: devlink linecard
569  */
570 void devlink_linecard_deactivate(struct devlink_linecard *linecard)
571 {
572 	mutex_lock(&linecard->state_lock);
573 	switch (linecard->state) {
574 	case DEVLINK_LINECARD_STATE_ACTIVE:
575 		linecard->state = DEVLINK_LINECARD_STATE_PROVISIONED;
576 		devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
577 		break;
578 	case DEVLINK_LINECARD_STATE_UNPROVISIONING:
579 		/* Line card is being deactivated as part
580 		 * of unprovisioning flow.
581 		 */
582 		break;
583 	default:
584 		WARN_ON(1);
585 		break;
586 	}
587 	mutex_unlock(&linecard->state_lock);
588 }
589 EXPORT_SYMBOL_GPL(devlink_linecard_deactivate);
590 
591 static void devlink_linecard_rel_notify_cb(struct devlink *devlink,
592 					   u32 linecard_index)
593 {
594 	struct devlink_linecard *linecard;
595 
596 	linecard = devlink_linecard_get_by_index(devlink, linecard_index);
597 	if (!linecard)
598 		return;
599 	devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
600 }
601 
602 static void devlink_linecard_rel_cleanup_cb(struct devlink *devlink,
603 					    u32 linecard_index, u32 rel_index)
604 {
605 	struct devlink_linecard *linecard;
606 
607 	linecard = devlink_linecard_get_by_index(devlink, linecard_index);
608 	if (linecard && linecard->rel_index == rel_index)
609 		linecard->rel_index = 0;
610 }
611 
612 /**
613  *	devlink_linecard_nested_dl_set - Attach/detach nested devlink
614  *					 instance to linecard.
615  *
616  *	@linecard: devlink linecard
617  *	@nested_devlink: devlink instance to attach or NULL to detach
618  */
619 int devlink_linecard_nested_dl_set(struct devlink_linecard *linecard,
620 				   struct devlink *nested_devlink)
621 {
622 	return devlink_rel_nested_in_add(&linecard->rel_index,
623 					 linecard->devlink->index,
624 					 linecard->index,
625 					 devlink_linecard_rel_notify_cb,
626 					 devlink_linecard_rel_cleanup_cb,
627 					 nested_devlink);
628 }
629 EXPORT_SYMBOL_GPL(devlink_linecard_nested_dl_set);
630