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