projects/linux·blob master · refs

627 lines · 16.9 KiB

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 <[email protected]>
5 */
6
7#include "devl_internal.h"
8
9struct 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
23unsigned int devlink_linecard_index(struct devlink_linecard *linecard)
24{
25 return linecard->index;
26}
27
28static struct devlink_linecard *
29devlink_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
41static 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
47static struct devlink_linecard *
48devlink_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
62static struct devlink_linecard *
63devlink_linecard_get_from_info(struct devlink *devlink, struct genl_info *info)
64{
65 return devlink_linecard_get_from_attrs(devlink, info->attrs);
66}
67
68struct devlink_linecard_type {
69 const char *type;
70 const void *priv;
71};
72
73static 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
124nla_put_failure:
125 genlmsg_cancel(msg, hdr);
126 return -EMSGSIZE;
127}
128
129static 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 (!__devl_is_registered(devlink) || !devlink_nl_notify_need(devlink))
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 devlink_nl_notify_send(devlink, msg);
154}
155
156void devlink_linecards_notify_register(struct devlink *devlink)
157{
158 struct devlink_linecard *linecard;
159
160 list_for_each_entry(linecard, &devlink->linecard_list, list)
161 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
162}
163
164void devlink_linecards_notify_unregister(struct devlink *devlink)
165{
166 struct devlink_linecard *linecard;
167
168 list_for_each_entry_reverse(linecard, &devlink->linecard_list, list)
169 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_DEL);
170}
171
172int devlink_nl_linecard_get_doit(struct sk_buff *skb, struct genl_info *info)
173{
174 struct devlink *devlink = devlink_nl_ctx(info)->devlink;
175 struct devlink_linecard *linecard;
176 struct sk_buff *msg;
177 int err;
178
179 linecard = devlink_linecard_get_from_info(devlink, info);
180 if (IS_ERR(linecard))
181 return PTR_ERR(linecard);
182
183 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
184 if (!msg)
185 return -ENOMEM;
186
187 mutex_lock(&linecard->state_lock);
188 err = devlink_nl_linecard_fill(msg, devlink, linecard,
189 DEVLINK_CMD_LINECARD_NEW,
190 info->snd_portid, info->snd_seq, 0,
191 info->extack);
192 mutex_unlock(&linecard->state_lock);
193 if (err) {
194 nlmsg_free(msg);
195 return err;
196 }
197
198 return genlmsg_reply(msg, info);
199}
200
201static int devlink_nl_linecard_get_dump_one(struct sk_buff *msg,
202 struct devlink *devlink,
203 struct netlink_callback *cb,
204 int flags)
205{
206 struct devlink_nl_dump_state *state = devlink_dump_state(cb);
207 struct devlink_linecard *linecard;
208 int idx = 0;
209 int err = 0;
210
211 list_for_each_entry(linecard, &devlink->linecard_list, list) {
212 if (idx < state->idx) {
213 idx++;
214 continue;
215 }
216 mutex_lock(&linecard->state_lock);
217 err = devlink_nl_linecard_fill(msg, devlink, linecard,
218 DEVLINK_CMD_LINECARD_NEW,
219 NETLINK_CB(cb->skb).portid,
220 cb->nlh->nlmsg_seq, flags,
221 cb->extack);
222 mutex_unlock(&linecard->state_lock);
223 if (err) {
224 state->idx = idx;
225 break;
226 }
227 idx++;
228 }
229
230 return err;
231}
232
233int devlink_nl_linecard_get_dumpit(struct sk_buff *skb,
234 struct netlink_callback *cb)
235{
236 return devlink_nl_dumpit(skb, cb, devlink_nl_linecard_get_dump_one);
237}
238
239static struct devlink_linecard_type *
240devlink_linecard_type_lookup(struct devlink_linecard *linecard,
241 const char *type)
242{
243 struct devlink_linecard_type *linecard_type;
244 int i;
245
246 for (i = 0; i < linecard->types_count; i++) {
247 linecard_type = &linecard->types[i];
248 if (!strcmp(type, linecard_type->type))
249 return linecard_type;
250 }
251 return NULL;
252}
253
254static int devlink_linecard_type_set(struct devlink_linecard *linecard,
255 const char *type,
256 struct netlink_ext_ack *extack)
257{
258 const struct devlink_linecard_ops *ops = linecard->ops;
259 struct devlink_linecard_type *linecard_type;
260 int err;
261
262 mutex_lock(&linecard->state_lock);
263 if (linecard->state == DEVLINK_LINECARD_STATE_PROVISIONING) {
264 NL_SET_ERR_MSG(extack, "Line card is currently being provisioned");
265 err = -EBUSY;
266 goto out;
267 }
268 if (linecard->state == DEVLINK_LINECARD_STATE_UNPROVISIONING) {
269 NL_SET_ERR_MSG(extack, "Line card is currently being unprovisioned");
270 err = -EBUSY;
271 goto out;
272 }
273
274 linecard_type = devlink_linecard_type_lookup(linecard, type);
275 if (!linecard_type) {
276 NL_SET_ERR_MSG(extack, "Unsupported line card type provided");
277 err = -EINVAL;
278 goto out;
279 }
280
281 if (linecard->state != DEVLINK_LINECARD_STATE_UNPROVISIONED &&
282 linecard->state != DEVLINK_LINECARD_STATE_PROVISIONING_FAILED) {
283 NL_SET_ERR_MSG(extack, "Line card already provisioned");
284 err = -EBUSY;
285 /* Check if the line card is provisioned in the same
286 * way the user asks. In case it is, make the operation
287 * to return success.
288 */
289 if (ops->same_provision &&
290 ops->same_provision(linecard, linecard->priv,
291 linecard_type->type,
292 linecard_type->priv))
293 err = 0;
294 goto out;
295 }
296
297 linecard->state = DEVLINK_LINECARD_STATE_PROVISIONING;
298 linecard->type = linecard_type->type;
299 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
300 mutex_unlock(&linecard->state_lock);
301 err = ops->provision(linecard, linecard->priv, linecard_type->type,
302 linecard_type->priv, extack);
303 if (err) {
304 /* Provisioning failed. Assume the linecard is unprovisioned
305 * for future operations.
306 */
307 mutex_lock(&linecard->state_lock);
308 linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
309 linecard->type = NULL;
310 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
311 mutex_unlock(&linecard->state_lock);
312 }
313 return err;
314
315out:
316 mutex_unlock(&linecard->state_lock);
317 return err;
318}
319
320static int devlink_linecard_type_unset(struct devlink_linecard *linecard,
321 struct netlink_ext_ack *extack)
322{
323 int err;
324
325 mutex_lock(&linecard->state_lock);
326 if (linecard->state == DEVLINK_LINECARD_STATE_PROVISIONING) {
327 NL_SET_ERR_MSG(extack, "Line card is currently being provisioned");
328 err = -EBUSY;
329 goto out;
330 }
331 if (linecard->state == DEVLINK_LINECARD_STATE_UNPROVISIONING) {
332 NL_SET_ERR_MSG(extack, "Line card is currently being unprovisioned");
333 err = -EBUSY;
334 goto out;
335 }
336 if (linecard->state == DEVLINK_LINECARD_STATE_PROVISIONING_FAILED) {
337 linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
338 linecard->type = NULL;
339 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
340 err = 0;
341 goto out;
342 }
343
344 if (linecard->state == DEVLINK_LINECARD_STATE_UNPROVISIONED) {
345 NL_SET_ERR_MSG(extack, "Line card is not provisioned");
346 err = 0;
347 goto out;
348 }
349 linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONING;
350 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
351 mutex_unlock(&linecard->state_lock);
352 err = linecard->ops->unprovision(linecard, linecard->priv,
353 extack);
354 if (err) {
355 /* Unprovisioning failed. Assume the linecard is unprovisioned
356 * for future operations.
357 */
358 mutex_lock(&linecard->state_lock);
359 linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
360 linecard->type = NULL;
361 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
362 mutex_unlock(&linecard->state_lock);
363 }
364 return err;
365
366out:
367 mutex_unlock(&linecard->state_lock);
368 return err;
369}
370
371int devlink_nl_linecard_set_doit(struct sk_buff *skb, struct genl_info *info)
372{
373 struct netlink_ext_ack *extack = info->extack;
374 struct devlink *devlink = devlink_nl_ctx(info)->devlink;
375 struct devlink_linecard *linecard;
376 int err;
377
378 linecard = devlink_linecard_get_from_info(devlink, info);
379 if (IS_ERR(linecard))
380 return PTR_ERR(linecard);
381
382 if (info->attrs[DEVLINK_ATTR_LINECARD_TYPE]) {
383 const char *type;
384
385 type = nla_data(info->attrs[DEVLINK_ATTR_LINECARD_TYPE]);
386 if (strcmp(type, "")) {
387 err = devlink_linecard_type_set(linecard, type, extack);
388 if (err)
389 return err;
390 } else {
391 err = devlink_linecard_type_unset(linecard, extack);
392 if (err)
393 return err;
394 }
395 }
396
397 return 0;
398}
399
400static int devlink_linecard_types_init(struct devlink_linecard *linecard)
401{
402 struct devlink_linecard_type *linecard_type;
403 unsigned int count;
404 int i;
405
406 count = linecard->ops->types_count(linecard, linecard->priv);
407 linecard->types = kmalloc_objs(*linecard_type, count);
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
421static 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 */
439struct devlink_linecard *
440devl_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_obj(*linecard);
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}
475EXPORT_SYMBOL_GPL(devl_linecard_create);
476
477/**
478 * devl_linecard_destroy - Destroy devlink linecard
479 *
480 * @linecard: devlink linecard
481 */
482void 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}
490EXPORT_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 */
501void 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}
511EXPORT_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 */
521void devlink_linecard_provision_clear(struct devlink_linecard *linecard)
522{
523 mutex_lock(&linecard->state_lock);
524 linecard->state = DEVLINK_LINECARD_STATE_UNPROVISIONED;
525 linecard->type = NULL;
526 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
527 mutex_unlock(&linecard->state_lock);
528}
529EXPORT_SYMBOL_GPL(devlink_linecard_provision_clear);
530
531/**
532 * devlink_linecard_provision_fail - Fail provisioning on linecard
533 *
534 * @linecard: devlink linecard
535 *
536 * This is either called directly from the provision() op call or
537 * as a result of the provision() op call asynchronously.
538 */
539void devlink_linecard_provision_fail(struct devlink_linecard *linecard)
540{
541 mutex_lock(&linecard->state_lock);
542 linecard->state = DEVLINK_LINECARD_STATE_PROVISIONING_FAILED;
543 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
544 mutex_unlock(&linecard->state_lock);
545}
546EXPORT_SYMBOL_GPL(devlink_linecard_provision_fail);
547
548/**
549 * devlink_linecard_activate - Set linecard active
550 *
551 * @linecard: devlink linecard
552 */
553void devlink_linecard_activate(struct devlink_linecard *linecard)
554{
555 mutex_lock(&linecard->state_lock);
556 WARN_ON(linecard->state != DEVLINK_LINECARD_STATE_PROVISIONED);
557 linecard->state = DEVLINK_LINECARD_STATE_ACTIVE;
558 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
559 mutex_unlock(&linecard->state_lock);
560}
561EXPORT_SYMBOL_GPL(devlink_linecard_activate);
562
563/**
564 * devlink_linecard_deactivate - Set linecard inactive
565 *
566 * @linecard: devlink linecard
567 */
568void devlink_linecard_deactivate(struct devlink_linecard *linecard)
569{
570 mutex_lock(&linecard->state_lock);
571 switch (linecard->state) {
572 case DEVLINK_LINECARD_STATE_ACTIVE:
573 linecard->state = DEVLINK_LINECARD_STATE_PROVISIONED;
574 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
575 break;
576 case DEVLINK_LINECARD_STATE_UNPROVISIONING:
577 /* Line card is being deactivated as part
578 * of unprovisioning flow.
579 */
580 break;
581 default:
582 WARN_ON(1);
583 break;
584 }
585 mutex_unlock(&linecard->state_lock);
586}
587EXPORT_SYMBOL_GPL(devlink_linecard_deactivate);
588
589static void devlink_linecard_rel_notify_cb(struct devlink *devlink,
590 u32 linecard_index)
591{
592 struct devlink_linecard *linecard;
593
594 linecard = devlink_linecard_get_by_index(devlink, linecard_index);
595 if (!linecard)
596 return;
597 devlink_linecard_notify(linecard, DEVLINK_CMD_LINECARD_NEW);
598}
599
600static void devlink_linecard_rel_cleanup_cb(struct devlink *devlink,
601 u32 linecard_index, u32 rel_index)
602{
603 struct devlink_linecard *linecard;
604
605 linecard = devlink_linecard_get_by_index(devlink, linecard_index);
606 if (linecard && linecard->rel_index == rel_index)
607 linecard->rel_index = 0;
608}
609
610/**
611 * devlink_linecard_nested_dl_set - Attach/detach nested devlink
612 * instance to linecard.
613 *
614 * @linecard: devlink linecard
615 * @nested_devlink: devlink instance to attach or NULL to detach
616 */
617int devlink_linecard_nested_dl_set(struct devlink_linecard *linecard,
618 struct devlink *nested_devlink)
619{
620 return devlink_rel_nested_in_add(&linecard->rel_index,
621 linecard->devlink->index,
622 linecard->index,
623 devlink_linecard_rel_notify_cb,
624 devlink_linecard_rel_cleanup_cb,
625 nested_devlink);
626}
627EXPORT_SYMBOL_GPL(devlink_linecard_nested_dl_set);