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 <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 work_struct 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); 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_work(&rel->nested_in.notify_work); 100 } 101 102 static void devlink_rel_nested_in_notify_work_schedule(struct devlink_rel *rel) 103 { 104 __devlink_rel_get(rel); 105 schedule_work(&rel->nested_in.notify_work); 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_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 void devlink_rel_nested_in_notify(struct devlink *devlink) 172 { 173 struct devlink_rel *rel = devlink->rel; 174 175 if (!rel) 176 return; 177 devlink_rel_nested_in_notify_work_schedule(rel); 178 } 179 180 static struct devlink_rel *devlink_rel_find(unsigned long rel_index) 181 { 182 return xa_find(&devlink_rels, &rel_index, rel_index, 183 DEVLINK_REL_IN_USE); 184 } 185 186 static struct devlink *devlink_rel_devlink_get(u32 rel_index) 187 { 188 struct devlink_rel *rel; 189 u32 devlink_index; 190 191 if (!rel_index) 192 return NULL; 193 xa_lock(&devlink_rels); 194 rel = devlink_rel_find(rel_index); 195 if (rel) 196 devlink_index = rel->devlink_index; 197 xa_unlock(&devlink_rels); 198 if (!rel) 199 return NULL; 200 return devlinks_xa_get(devlink_index); 201 } 202 203 int devlink_rel_devlink_handle_put(struct sk_buff *msg, struct devlink *devlink, 204 u32 rel_index, int attrtype, 205 bool *msg_updated) 206 { 207 struct net *net = devlink_net(devlink); 208 struct devlink *rel_devlink; 209 int err; 210 211 rel_devlink = devlink_rel_devlink_get(rel_index); 212 if (!rel_devlink) 213 return 0; 214 err = devlink_nl_put_nested_handle(msg, net, rel_devlink, attrtype); 215 devlink_put(rel_devlink); 216 if (!err && msg_updated) 217 *msg_updated = true; 218 return err; 219 } 220 221 void *devlink_priv(struct devlink *devlink) 222 { 223 return &devlink->priv; 224 } 225 EXPORT_SYMBOL_GPL(devlink_priv); 226 227 struct devlink *priv_to_devlink(void *priv) 228 { 229 return container_of(priv, struct devlink, priv); 230 } 231 EXPORT_SYMBOL_GPL(priv_to_devlink); 232 233 struct device *devlink_to_dev(const struct devlink *devlink) 234 { 235 return devlink->dev; 236 } 237 EXPORT_SYMBOL_GPL(devlink_to_dev); 238 239 struct net *devlink_net(const struct devlink *devlink) 240 { 241 return read_pnet(&devlink->_net); 242 } 243 EXPORT_SYMBOL_GPL(devlink_net); 244 245 void devl_assert_locked(struct devlink *devlink) 246 { 247 lockdep_assert_held(&devlink->lock); 248 } 249 EXPORT_SYMBOL_GPL(devl_assert_locked); 250 251 #ifdef CONFIG_LOCKDEP 252 /* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */ 253 bool devl_lock_is_held(struct devlink *devlink) 254 { 255 return lockdep_is_held(&devlink->lock); 256 } 257 EXPORT_SYMBOL_GPL(devl_lock_is_held); 258 #endif 259 260 void devl_lock(struct devlink *devlink) 261 { 262 mutex_lock(&devlink->lock); 263 } 264 EXPORT_SYMBOL_GPL(devl_lock); 265 266 int devl_trylock(struct devlink *devlink) 267 { 268 return mutex_trylock(&devlink->lock); 269 } 270 EXPORT_SYMBOL_GPL(devl_trylock); 271 272 void devl_unlock(struct devlink *devlink) 273 { 274 mutex_unlock(&devlink->lock); 275 } 276 EXPORT_SYMBOL_GPL(devl_unlock); 277 278 /** 279 * devlink_try_get() - try to obtain a reference on a devlink instance 280 * @devlink: instance to reference 281 * 282 * Obtain a reference on a devlink instance. A reference on a devlink instance 283 * only implies that it's safe to take the instance lock. It does not imply 284 * that the instance is registered, use devl_is_registered() after taking 285 * the instance lock to check registration status. 286 */ 287 struct devlink *__must_check devlink_try_get(struct devlink *devlink) 288 { 289 if (refcount_inc_not_zero(&devlink->refcount)) 290 return devlink; 291 return NULL; 292 } 293 294 static void devlink_release(struct work_struct *work) 295 { 296 struct devlink *devlink; 297 298 devlink = container_of(to_rcu_work(work), struct devlink, rwork); 299 300 mutex_destroy(&devlink->lock); 301 lockdep_unregister_key(&devlink->lock_key); 302 put_device(devlink->dev); 303 kfree(devlink); 304 } 305 306 void devlink_put(struct devlink *devlink) 307 { 308 if (refcount_dec_and_test(&devlink->refcount)) 309 queue_rcu_work(system_wq, &devlink->rwork); 310 } 311 312 struct devlink *devlinks_xa_find_get(struct net *net, unsigned long *indexp) 313 { 314 struct devlink *devlink = NULL; 315 316 rcu_read_lock(); 317 retry: 318 devlink = xa_find(&devlinks, indexp, ULONG_MAX, DEVLINK_REGISTERED); 319 if (!devlink) 320 goto unlock; 321 322 if (!devlink_try_get(devlink)) 323 goto next; 324 if (!net_eq(devlink_net(devlink), net)) { 325 devlink_put(devlink); 326 goto next; 327 } 328 unlock: 329 rcu_read_unlock(); 330 return devlink; 331 332 next: 333 (*indexp)++; 334 goto retry; 335 } 336 337 /** 338 * devl_register - Register devlink instance 339 * @devlink: devlink 340 */ 341 int devl_register(struct devlink *devlink) 342 { 343 ASSERT_DEVLINK_NOT_REGISTERED(devlink); 344 devl_assert_locked(devlink); 345 346 xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED); 347 devlink_notify_register(devlink); 348 devlink_rel_nested_in_notify(devlink); 349 350 return 0; 351 } 352 EXPORT_SYMBOL_GPL(devl_register); 353 354 void devlink_register(struct devlink *devlink) 355 { 356 devl_lock(devlink); 357 devl_register(devlink); 358 devl_unlock(devlink); 359 } 360 EXPORT_SYMBOL_GPL(devlink_register); 361 362 /** 363 * devl_unregister - Unregister devlink instance 364 * @devlink: devlink 365 */ 366 void devl_unregister(struct devlink *devlink) 367 { 368 ASSERT_DEVLINK_REGISTERED(devlink); 369 devl_assert_locked(devlink); 370 371 devlink_notify_unregister(devlink); 372 xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED); 373 devlink_rel_put(devlink); 374 } 375 EXPORT_SYMBOL_GPL(devl_unregister); 376 377 void devlink_unregister(struct devlink *devlink) 378 { 379 devl_lock(devlink); 380 devl_unregister(devlink); 381 devl_unlock(devlink); 382 } 383 EXPORT_SYMBOL_GPL(devlink_unregister); 384 385 /** 386 * devlink_alloc_ns - Allocate new devlink instance resources 387 * in specific namespace 388 * 389 * @ops: ops 390 * @priv_size: size of user private data 391 * @net: net namespace 392 * @dev: parent device 393 * 394 * Allocate new devlink instance resources, including devlink index 395 * and name. 396 */ 397 struct devlink *devlink_alloc_ns(const struct devlink_ops *ops, 398 size_t priv_size, struct net *net, 399 struct device *dev) 400 { 401 struct devlink *devlink; 402 static u32 last_id; 403 int ret; 404 405 WARN_ON(!ops || !dev); 406 if (!devlink_reload_actions_valid(ops)) 407 return NULL; 408 409 devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL); 410 if (!devlink) 411 return NULL; 412 413 ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b, 414 &last_id, GFP_KERNEL); 415 if (ret < 0) 416 goto err_xa_alloc; 417 418 devlink->dev = get_device(dev); 419 devlink->ops = ops; 420 xa_init_flags(&devlink->ports, XA_FLAGS_ALLOC); 421 xa_init_flags(&devlink->params, XA_FLAGS_ALLOC); 422 xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC); 423 xa_init_flags(&devlink->nested_rels, XA_FLAGS_ALLOC); 424 write_pnet(&devlink->_net, net); 425 INIT_LIST_HEAD(&devlink->rate_list); 426 INIT_LIST_HEAD(&devlink->linecard_list); 427 INIT_LIST_HEAD(&devlink->sb_list); 428 INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list); 429 INIT_LIST_HEAD(&devlink->resource_list); 430 INIT_LIST_HEAD(&devlink->region_list); 431 INIT_LIST_HEAD(&devlink->reporter_list); 432 INIT_LIST_HEAD(&devlink->trap_list); 433 INIT_LIST_HEAD(&devlink->trap_group_list); 434 INIT_LIST_HEAD(&devlink->trap_policer_list); 435 INIT_RCU_WORK(&devlink->rwork, devlink_release); 436 lockdep_register_key(&devlink->lock_key); 437 mutex_init(&devlink->lock); 438 lockdep_set_class(&devlink->lock, &devlink->lock_key); 439 refcount_set(&devlink->refcount, 1); 440 441 return devlink; 442 443 err_xa_alloc: 444 kfree(devlink); 445 return NULL; 446 } 447 EXPORT_SYMBOL_GPL(devlink_alloc_ns); 448 449 /** 450 * devlink_free - Free devlink instance resources 451 * 452 * @devlink: devlink 453 */ 454 void devlink_free(struct devlink *devlink) 455 { 456 ASSERT_DEVLINK_NOT_REGISTERED(devlink); 457 458 WARN_ON(!list_empty(&devlink->trap_policer_list)); 459 WARN_ON(!list_empty(&devlink->trap_group_list)); 460 WARN_ON(!list_empty(&devlink->trap_list)); 461 WARN_ON(!list_empty(&devlink->reporter_list)); 462 WARN_ON(!list_empty(&devlink->region_list)); 463 WARN_ON(!list_empty(&devlink->resource_list)); 464 WARN_ON(!list_empty(&devlink->dpipe_table_list)); 465 WARN_ON(!list_empty(&devlink->sb_list)); 466 WARN_ON(!list_empty(&devlink->rate_list)); 467 WARN_ON(!list_empty(&devlink->linecard_list)); 468 WARN_ON(!xa_empty(&devlink->ports)); 469 470 xa_destroy(&devlink->nested_rels); 471 xa_destroy(&devlink->snapshot_ids); 472 xa_destroy(&devlink->params); 473 xa_destroy(&devlink->ports); 474 475 xa_erase(&devlinks, devlink->index); 476 477 devlink_put(devlink); 478 } 479 EXPORT_SYMBOL_GPL(devlink_free); 480 481 static void __net_exit devlink_pernet_pre_exit(struct net *net) 482 { 483 struct devlink *devlink; 484 u32 actions_performed; 485 unsigned long index; 486 int err; 487 488 /* In case network namespace is getting destroyed, reload 489 * all devlink instances from this namespace into init_net. 490 */ 491 devlinks_xa_for_each_registered_get(net, index, devlink) { 492 devl_lock(devlink); 493 err = 0; 494 if (devl_is_registered(devlink)) 495 err = devlink_reload(devlink, &init_net, 496 DEVLINK_RELOAD_ACTION_DRIVER_REINIT, 497 DEVLINK_RELOAD_LIMIT_UNSPEC, 498 &actions_performed, NULL); 499 devl_unlock(devlink); 500 devlink_put(devlink); 501 if (err && err != -EOPNOTSUPP) 502 pr_warn("Failed to reload devlink instance into init_net\n"); 503 } 504 } 505 506 static struct pernet_operations devlink_pernet_ops __net_initdata = { 507 .pre_exit = devlink_pernet_pre_exit, 508 }; 509 510 static struct notifier_block devlink_port_netdevice_nb = { 511 .notifier_call = devlink_port_netdevice_event, 512 }; 513 514 static int __init devlink_init(void) 515 { 516 int err; 517 518 err = genl_register_family(&devlink_nl_family); 519 if (err) 520 goto out; 521 err = register_pernet_subsys(&devlink_pernet_ops); 522 if (err) 523 goto out; 524 err = register_netdevice_notifier(&devlink_port_netdevice_nb); 525 526 out: 527 WARN_ON(err); 528 return err; 529 } 530 531 subsys_initcall(devlink_init); 532