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 <net/genetlink.h> 8 #define CREATE_TRACE_POINTS 9 #include <trace/events/devlink.h> 10 11 #include "devl_internal.h" 12 13 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg); 14 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwerr); 15 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_trap_report); 16 17 DEFINE_XARRAY_FLAGS(devlinks, XA_FLAGS_ALLOC); 18 19 static struct devlink *devlinks_xa_get(unsigned long index) 20 { 21 struct devlink *devlink; 22 23 rcu_read_lock(); 24 devlink = xa_find(&devlinks, &index, index, DEVLINK_REGISTERED); 25 if (!devlink || !devlink_try_get(devlink)) 26 devlink = NULL; 27 rcu_read_unlock(); 28 return devlink; 29 } 30 31 /* devlink_rels xarray contains 1:1 relationships between 32 * devlink object and related nested devlink instance. 33 * The xarray index is used to get the nested object from 34 * the nested-in object code. 35 */ 36 static DEFINE_XARRAY_FLAGS(devlink_rels, XA_FLAGS_ALLOC1); 37 38 #define DEVLINK_REL_IN_USE XA_MARK_0 39 40 struct devlink_rel { 41 u32 index; 42 refcount_t refcount; 43 u32 devlink_index; 44 struct { 45 u32 devlink_index; 46 u32 obj_index; 47 devlink_rel_notify_cb_t *notify_cb; 48 devlink_rel_cleanup_cb_t *cleanup_cb; 49 struct delayed_work notify_work; 50 } nested_in; 51 }; 52 53 static void devlink_rel_free(struct devlink_rel *rel) 54 { 55 xa_erase(&devlink_rels, rel->index); 56 kfree(rel); 57 } 58 59 static void __devlink_rel_get(struct devlink_rel *rel) 60 { 61 refcount_inc(&rel->refcount); 62 } 63 64 static void __devlink_rel_put(struct devlink_rel *rel) 65 { 66 if (refcount_dec_and_test(&rel->refcount)) 67 devlink_rel_free(rel); 68 } 69 70 static void devlink_rel_nested_in_notify_work(struct work_struct *work) 71 { 72 struct devlink_rel *rel = container_of(work, struct devlink_rel, 73 nested_in.notify_work.work); 74 struct devlink *devlink; 75 76 devlink = devlinks_xa_get(rel->nested_in.devlink_index); 77 if (!devlink) 78 goto rel_put; 79 if (!devl_trylock(devlink)) { 80 devlink_put(devlink); 81 goto reschedule_work; 82 } 83 if (!devl_is_registered(devlink)) { 84 devl_unlock(devlink); 85 devlink_put(devlink); 86 goto rel_put; 87 } 88 if (!xa_get_mark(&devlink_rels, rel->index, DEVLINK_REL_IN_USE)) 89 rel->nested_in.cleanup_cb(devlink, rel->nested_in.obj_index, rel->index); 90 rel->nested_in.notify_cb(devlink, rel->nested_in.obj_index); 91 devl_unlock(devlink); 92 devlink_put(devlink); 93 94 rel_put: 95 __devlink_rel_put(rel); 96 return; 97 98 reschedule_work: 99 schedule_delayed_work(&rel->nested_in.notify_work, 1); 100 } 101 102 static void devlink_rel_nested_in_notify_work_schedule(struct devlink_rel *rel) 103 { 104 __devlink_rel_get(rel); 105 schedule_delayed_work(&rel->nested_in.notify_work, 0); 106 } 107 108 static struct devlink_rel *devlink_rel_alloc(void) 109 { 110 struct devlink_rel *rel; 111 static u32 next; 112 int err; 113 114 rel = kzalloc(sizeof(*rel), GFP_KERNEL); 115 if (!rel) 116 return ERR_PTR(-ENOMEM); 117 118 err = xa_alloc_cyclic(&devlink_rels, &rel->index, rel, 119 xa_limit_32b, &next, GFP_KERNEL); 120 if (err) { 121 kfree(rel); 122 return ERR_PTR(err); 123 } 124 125 refcount_set(&rel->refcount, 1); 126 INIT_DELAYED_WORK(&rel->nested_in.notify_work, 127 &devlink_rel_nested_in_notify_work); 128 return rel; 129 } 130 131 static void devlink_rel_put(struct devlink *devlink) 132 { 133 struct devlink_rel *rel = devlink->rel; 134 135 if (!rel) 136 return; 137 xa_clear_mark(&devlink_rels, rel->index, DEVLINK_REL_IN_USE); 138 devlink_rel_nested_in_notify_work_schedule(rel); 139 __devlink_rel_put(rel); 140 devlink->rel = NULL; 141 } 142 143 void devlink_rel_nested_in_clear(u32 rel_index) 144 { 145 xa_clear_mark(&devlink_rels, rel_index, DEVLINK_REL_IN_USE); 146 } 147 148 int devlink_rel_nested_in_add(u32 *rel_index, u32 devlink_index, 149 u32 obj_index, devlink_rel_notify_cb_t *notify_cb, 150 devlink_rel_cleanup_cb_t *cleanup_cb, 151 struct devlink *devlink) 152 { 153 struct devlink_rel *rel = devlink_rel_alloc(); 154 155 ASSERT_DEVLINK_NOT_REGISTERED(devlink); 156 157 if (IS_ERR(rel)) 158 return PTR_ERR(rel); 159 160 rel->devlink_index = devlink->index; 161 rel->nested_in.devlink_index = devlink_index; 162 rel->nested_in.obj_index = obj_index; 163 rel->nested_in.notify_cb = notify_cb; 164 rel->nested_in.cleanup_cb = cleanup_cb; 165 *rel_index = rel->index; 166 xa_set_mark(&devlink_rels, rel->index, DEVLINK_REL_IN_USE); 167 devlink->rel = rel; 168 return 0; 169 } 170 171 /** 172 * devlink_rel_nested_in_notify - Notify the object this devlink 173 * instance is nested in. 174 * @devlink: devlink 175 * 176 * This is called upon network namespace change of devlink instance. 177 * In case this devlink instance is nested in another devlink object, 178 * a notification of a change of this object should be sent 179 * over netlink. The parent devlink instance lock needs to be 180 * taken during the notification preparation. 181 * However, since the devlink lock of nested instance is held here, 182 * we would end with wrong devlink instance lock ordering and 183 * deadlock. Therefore the work is utilized to avoid that. 184 */ 185 void devlink_rel_nested_in_notify(struct devlink *devlink) 186 { 187 struct devlink_rel *rel = devlink->rel; 188 189 if (!rel) 190 return; 191 devlink_rel_nested_in_notify_work_schedule(rel); 192 } 193 194 static struct devlink_rel *devlink_rel_find(unsigned long rel_index) 195 { 196 return xa_find(&devlink_rels, &rel_index, rel_index, 197 DEVLINK_REL_IN_USE); 198 } 199 200 static struct devlink *devlink_rel_devlink_get(u32 rel_index) 201 { 202 struct devlink_rel *rel; 203 u32 devlink_index; 204 205 if (!rel_index) 206 return NULL; 207 xa_lock(&devlink_rels); 208 rel = devlink_rel_find(rel_index); 209 if (rel) 210 devlink_index = rel->devlink_index; 211 xa_unlock(&devlink_rels); 212 if (!rel) 213 return NULL; 214 return devlinks_xa_get(devlink_index); 215 } 216 217 int devlink_rel_devlink_handle_put(struct sk_buff *msg, struct devlink *devlink, 218 u32 rel_index, int attrtype, 219 bool *msg_updated) 220 { 221 struct net *net = devlink_net(devlink); 222 struct devlink *rel_devlink; 223 int err; 224 225 rel_devlink = devlink_rel_devlink_get(rel_index); 226 if (!rel_devlink) 227 return 0; 228 err = devlink_nl_put_nested_handle(msg, net, rel_devlink, attrtype); 229 devlink_put(rel_devlink); 230 if (!err && msg_updated) 231 *msg_updated = true; 232 return err; 233 } 234 235 void *devlink_priv(struct devlink *devlink) 236 { 237 return &devlink->priv; 238 } 239 EXPORT_SYMBOL_GPL(devlink_priv); 240 241 struct devlink *priv_to_devlink(void *priv) 242 { 243 return container_of(priv, struct devlink, priv); 244 } 245 EXPORT_SYMBOL_GPL(priv_to_devlink); 246 247 struct device *devlink_to_dev(const struct devlink *devlink) 248 { 249 return devlink->dev; 250 } 251 EXPORT_SYMBOL_GPL(devlink_to_dev); 252 253 struct net *devlink_net(const struct devlink *devlink) 254 { 255 return read_pnet(&devlink->_net); 256 } 257 EXPORT_SYMBOL_GPL(devlink_net); 258 259 void devl_assert_locked(struct devlink *devlink) 260 { 261 lockdep_assert_held(&devlink->lock); 262 } 263 EXPORT_SYMBOL_GPL(devl_assert_locked); 264 265 #ifdef CONFIG_LOCKDEP 266 /* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */ 267 bool devl_lock_is_held(struct devlink *devlink) 268 { 269 return lockdep_is_held(&devlink->lock); 270 } 271 EXPORT_SYMBOL_GPL(devl_lock_is_held); 272 #endif 273 274 void devl_lock(struct devlink *devlink) 275 { 276 mutex_lock(&devlink->lock); 277 } 278 EXPORT_SYMBOL_GPL(devl_lock); 279 280 int devl_trylock(struct devlink *devlink) 281 { 282 return mutex_trylock(&devlink->lock); 283 } 284 EXPORT_SYMBOL_GPL(devl_trylock); 285 286 void devl_unlock(struct devlink *devlink) 287 { 288 mutex_unlock(&devlink->lock); 289 } 290 EXPORT_SYMBOL_GPL(devl_unlock); 291 292 /** 293 * devlink_try_get() - try to obtain a reference on a devlink instance 294 * @devlink: instance to reference 295 * 296 * Obtain a reference on a devlink instance. A reference on a devlink instance 297 * only implies that it's safe to take the instance lock. It does not imply 298 * that the instance is registered, use devl_is_registered() after taking 299 * the instance lock to check registration status. 300 */ 301 struct devlink *__must_check devlink_try_get(struct devlink *devlink) 302 { 303 if (refcount_inc_not_zero(&devlink->refcount)) 304 return devlink; 305 return NULL; 306 } 307 308 static void devlink_release(struct work_struct *work) 309 { 310 struct devlink *devlink; 311 312 devlink = container_of(to_rcu_work(work), struct devlink, rwork); 313 314 mutex_destroy(&devlink->lock); 315 lockdep_unregister_key(&devlink->lock_key); 316 put_device(devlink->dev); 317 kfree(devlink); 318 } 319 320 void devlink_put(struct devlink *devlink) 321 { 322 if (refcount_dec_and_test(&devlink->refcount)) 323 queue_rcu_work(system_wq, &devlink->rwork); 324 } 325 326 struct devlink *devlinks_xa_find_get(struct net *net, unsigned long *indexp) 327 { 328 struct devlink *devlink = NULL; 329 330 rcu_read_lock(); 331 retry: 332 devlink = xa_find(&devlinks, indexp, ULONG_MAX, DEVLINK_REGISTERED); 333 if (!devlink) 334 goto unlock; 335 336 if (!devlink_try_get(devlink)) 337 goto next; 338 if (!net_eq(devlink_net(devlink), net)) { 339 devlink_put(devlink); 340 goto next; 341 } 342 unlock: 343 rcu_read_unlock(); 344 return devlink; 345 346 next: 347 (*indexp)++; 348 goto retry; 349 } 350 351 /** 352 * devl_register - Register devlink instance 353 * @devlink: devlink 354 */ 355 int devl_register(struct devlink *devlink) 356 { 357 ASSERT_DEVLINK_NOT_REGISTERED(devlink); 358 devl_assert_locked(devlink); 359 360 xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED); 361 devlink_notify_register(devlink); 362 devlink_rel_nested_in_notify(devlink); 363 364 return 0; 365 } 366 EXPORT_SYMBOL_GPL(devl_register); 367 368 void devlink_register(struct devlink *devlink) 369 { 370 devl_lock(devlink); 371 devl_register(devlink); 372 devl_unlock(devlink); 373 } 374 EXPORT_SYMBOL_GPL(devlink_register); 375 376 /** 377 * devl_unregister - Unregister devlink instance 378 * @devlink: devlink 379 */ 380 void devl_unregister(struct devlink *devlink) 381 { 382 ASSERT_DEVLINK_REGISTERED(devlink); 383 devl_assert_locked(devlink); 384 385 devlink_notify_unregister(devlink); 386 xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED); 387 devlink_rel_put(devlink); 388 } 389 EXPORT_SYMBOL_GPL(devl_unregister); 390 391 void devlink_unregister(struct devlink *devlink) 392 { 393 devl_lock(devlink); 394 devl_unregister(devlink); 395 devl_unlock(devlink); 396 } 397 EXPORT_SYMBOL_GPL(devlink_unregister); 398 399 /** 400 * devlink_alloc_ns - Allocate new devlink instance resources 401 * in specific namespace 402 * 403 * @ops: ops 404 * @priv_size: size of user private data 405 * @net: net namespace 406 * @dev: parent device 407 * 408 * Allocate new devlink instance resources, including devlink index 409 * and name. 410 */ 411 struct devlink *devlink_alloc_ns(const struct devlink_ops *ops, 412 size_t priv_size, struct net *net, 413 struct device *dev) 414 { 415 struct devlink *devlink; 416 static u32 last_id; 417 int ret; 418 419 WARN_ON(!ops || !dev); 420 if (!devlink_reload_actions_valid(ops)) 421 return NULL; 422 423 devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL); 424 if (!devlink) 425 return NULL; 426 427 ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b, 428 &last_id, GFP_KERNEL); 429 if (ret < 0) 430 goto err_xa_alloc; 431 432 devlink->dev = get_device(dev); 433 devlink->ops = ops; 434 xa_init_flags(&devlink->ports, XA_FLAGS_ALLOC); 435 xa_init_flags(&devlink->params, XA_FLAGS_ALLOC); 436 xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC); 437 xa_init_flags(&devlink->nested_rels, XA_FLAGS_ALLOC); 438 write_pnet(&devlink->_net, net); 439 INIT_LIST_HEAD(&devlink->rate_list); 440 INIT_LIST_HEAD(&devlink->linecard_list); 441 INIT_LIST_HEAD(&devlink->sb_list); 442 INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list); 443 INIT_LIST_HEAD(&devlink->resource_list); 444 INIT_LIST_HEAD(&devlink->region_list); 445 INIT_LIST_HEAD(&devlink->reporter_list); 446 INIT_LIST_HEAD(&devlink->trap_list); 447 INIT_LIST_HEAD(&devlink->trap_group_list); 448 INIT_LIST_HEAD(&devlink->trap_policer_list); 449 INIT_RCU_WORK(&devlink->rwork, devlink_release); 450 lockdep_register_key(&devlink->lock_key); 451 mutex_init(&devlink->lock); 452 lockdep_set_class(&devlink->lock, &devlink->lock_key); 453 refcount_set(&devlink->refcount, 1); 454 455 return devlink; 456 457 err_xa_alloc: 458 kfree(devlink); 459 return NULL; 460 } 461 EXPORT_SYMBOL_GPL(devlink_alloc_ns); 462 463 /** 464 * devlink_free - Free devlink instance resources 465 * 466 * @devlink: devlink 467 */ 468 void devlink_free(struct devlink *devlink) 469 { 470 ASSERT_DEVLINK_NOT_REGISTERED(devlink); 471 472 WARN_ON(!list_empty(&devlink->trap_policer_list)); 473 WARN_ON(!list_empty(&devlink->trap_group_list)); 474 WARN_ON(!list_empty(&devlink->trap_list)); 475 WARN_ON(!list_empty(&devlink->reporter_list)); 476 WARN_ON(!list_empty(&devlink->region_list)); 477 WARN_ON(!list_empty(&devlink->resource_list)); 478 WARN_ON(!list_empty(&devlink->dpipe_table_list)); 479 WARN_ON(!list_empty(&devlink->sb_list)); 480 WARN_ON(!list_empty(&devlink->rate_list)); 481 WARN_ON(!list_empty(&devlink->linecard_list)); 482 WARN_ON(!xa_empty(&devlink->ports)); 483 484 xa_destroy(&devlink->nested_rels); 485 xa_destroy(&devlink->snapshot_ids); 486 xa_destroy(&devlink->params); 487 xa_destroy(&devlink->ports); 488 489 xa_erase(&devlinks, devlink->index); 490 491 devlink_put(devlink); 492 } 493 EXPORT_SYMBOL_GPL(devlink_free); 494 495 static void __net_exit devlink_pernet_pre_exit(struct net *net) 496 { 497 struct devlink *devlink; 498 u32 actions_performed; 499 unsigned long index; 500 int err; 501 502 /* In case network namespace is getting destroyed, reload 503 * all devlink instances from this namespace into init_net. 504 */ 505 devlinks_xa_for_each_registered_get(net, index, devlink) { 506 devl_dev_lock(devlink, true); 507 err = 0; 508 if (devl_is_registered(devlink)) 509 err = devlink_reload(devlink, &init_net, 510 DEVLINK_RELOAD_ACTION_DRIVER_REINIT, 511 DEVLINK_RELOAD_LIMIT_UNSPEC, 512 &actions_performed, NULL); 513 devl_dev_unlock(devlink, true); 514 devlink_put(devlink); 515 if (err && err != -EOPNOTSUPP) 516 pr_warn("Failed to reload devlink instance into init_net\n"); 517 } 518 } 519 520 static struct pernet_operations devlink_pernet_ops __net_initdata = { 521 .pre_exit = devlink_pernet_pre_exit, 522 }; 523 524 static struct notifier_block devlink_port_netdevice_nb = { 525 .notifier_call = devlink_port_netdevice_event, 526 }; 527 528 static int __init devlink_init(void) 529 { 530 int err; 531 532 err = register_pernet_subsys(&devlink_pernet_ops); 533 if (err) 534 goto out; 535 err = genl_register_family(&devlink_nl_family); 536 if (err) 537 goto out_unreg_pernet_subsys; 538 err = register_netdevice_notifier(&devlink_port_netdevice_nb); 539 if (!err) 540 return 0; 541 542 genl_unregister_family(&devlink_nl_family); 543 544 out_unreg_pernet_subsys: 545 unregister_pernet_subsys(&devlink_pernet_ops); 546 out: 547 WARN_ON(err); 548 return err; 549 } 550 551 subsys_initcall(devlink_init); 552