net/devlink/core.c

   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 void *devlink_priv(struct devlink *devlink)
  20 {
  21         return &devlink->priv;
  22 }
  23 EXPORT_SYMBOL_GPL(devlink_priv);
  24
  25 struct devlink *priv_to_devlink(void *priv)
  26 {
  27         return container_of(priv, struct devlink, priv);
  28 }
  29 EXPORT_SYMBOL_GPL(priv_to_devlink);
  30
  31 struct device *devlink_to_dev(const struct devlink *devlink)
  32 {
  33         return devlink->dev;
  34 }
  35 EXPORT_SYMBOL_GPL(devlink_to_dev);
  36
  37 struct net *devlink_net(const struct devlink *devlink)
  38 {
  39         return read_pnet(&devlink->_net);
  40 }
  41 EXPORT_SYMBOL_GPL(devlink_net);
  42
  43 void devl_assert_locked(struct devlink *devlink)
  44 {
  45         lockdep_assert_held(&devlink->lock);
  46 }
  47 EXPORT_SYMBOL_GPL(devl_assert_locked);
  48
  49 #ifdef CONFIG_LOCKDEP
  50 /* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */
  51 bool devl_lock_is_held(struct devlink *devlink)
  52 {
  53         return lockdep_is_held(&devlink->lock);
  54 }
  55 EXPORT_SYMBOL_GPL(devl_lock_is_held);
  56 #endif
  57
  58 void devl_lock(struct devlink *devlink)
  59 {
  60         mutex_lock(&devlink->lock);
  61 }
  62 EXPORT_SYMBOL_GPL(devl_lock);
  63
  64 int devl_trylock(struct devlink *devlink)
  65 {
  66         return mutex_trylock(&devlink->lock);
  67 }
  68 EXPORT_SYMBOL_GPL(devl_trylock);
  69
  70 void devl_unlock(struct devlink *devlink)
  71 {
  72         mutex_unlock(&devlink->lock);
  73 }
  74 EXPORT_SYMBOL_GPL(devl_unlock);
  75
  76 /**
  77  * devlink_try_get() - try to obtain a reference on a devlink instance
  78  * @devlink: instance to reference
  79  *
  80  * Obtain a reference on a devlink instance. A reference on a devlink instance
  81  * only implies that it's safe to take the instance lock. It does not imply
  82  * that the instance is registered, use devl_is_registered() after taking
  83  * the instance lock to check registration status.
  84  */
  85 struct devlink *__must_check devlink_try_get(struct devlink *devlink)
  86 {
  87         if (refcount_inc_not_zero(&devlink->refcount))
  88                 return devlink;
  89         return NULL;
  90 }
  91
  92 static void devlink_release(struct work_struct *work)
  93 {
  94         struct devlink *devlink;
  95
  96         devlink = container_of(to_rcu_work(work), struct devlink, rwork);
  97
  98         mutex_destroy(&devlink->lock);
  99         lockdep_unregister_key(&devlink->lock_key);
 100         kfree(devlink);
 101 }
 102
 103 void devlink_put(struct devlink *devlink)
 104 {
 105         if (refcount_dec_and_test(&devlink->refcount))
 106                 queue_rcu_work(system_wq, &devlink->rwork);
 107 }
 108
 109 struct devlink *devlinks_xa_find_get(struct net *net, unsigned long *indexp)
 110 {
 111         struct devlink *devlink = NULL;
 112
 113         rcu_read_lock();
 114 retry:
 115         devlink = xa_find(&devlinks, indexp, ULONG_MAX, DEVLINK_REGISTERED);
 116         if (!devlink)
 117                 goto unlock;
 118
 119         if (!devlink_try_get(devlink))
 120                 goto next;
 121         if (!net_eq(devlink_net(devlink), net)) {
 122                 devlink_put(devlink);
 123                 goto next;
 124         }
 125 unlock:
 126         rcu_read_unlock();
 127         return devlink;
 128
 129 next:
 130         (*indexp)++;
 131         goto retry;
 132 }
 133
 134 /**
 135  * devl_register - Register devlink instance
 136  * @devlink: devlink
 137  */
 138 int devl_register(struct devlink *devlink)
 139 {
 140         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
 141         devl_assert_locked(devlink);
 142
 143         xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
 144         devlink_notify_register(devlink);
 145
 146         return 0;
 147 }
 148 EXPORT_SYMBOL_GPL(devl_register);
 149
 150 void devlink_register(struct devlink *devlink)
 151 {
 152         devl_lock(devlink);
 153         devl_register(devlink);
 154         devl_unlock(devlink);
 155 }
 156 EXPORT_SYMBOL_GPL(devlink_register);
 157
 158 /**
 159  * devl_unregister - Unregister devlink instance
 160  * @devlink: devlink
 161  */
 162 void devl_unregister(struct devlink *devlink)
 163 {
 164         ASSERT_DEVLINK_REGISTERED(devlink);
 165         devl_assert_locked(devlink);
 166
 167         devlink_notify_unregister(devlink);
 168         xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
 169 }
 170 EXPORT_SYMBOL_GPL(devl_unregister);
 171
 172 void devlink_unregister(struct devlink *devlink)
 173 {
 174         devl_lock(devlink);
 175         devl_unregister(devlink);
 176         devl_unlock(devlink);
 177 }
 178 EXPORT_SYMBOL_GPL(devlink_unregister);
 179
 180 /**
 181  *      devlink_alloc_ns - Allocate new devlink instance resources
 182  *      in specific namespace
 183  *
 184  *      @ops: ops
 185  *      @priv_size: size of user private data
 186  *      @net: net namespace
 187  *      @dev: parent device
 188  *
 189  *      Allocate new devlink instance resources, including devlink index
 190  *      and name.
 191  */
 192 struct devlink *devlink_alloc_ns(const struct devlink_ops *ops,
 193                                  size_t priv_size, struct net *net,
 194                                  struct device *dev)
 195 {
 196         struct devlink *devlink;
 197         static u32 last_id;
 198         int ret;
 199
 200         WARN_ON(!ops || !dev);
 201         if (!devlink_reload_actions_valid(ops))
 202                 return NULL;
 203
 204         devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
 205         if (!devlink)
 206                 return NULL;
 207
 208         ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b,
 209                               &last_id, GFP_KERNEL);
 210         if (ret < 0)
 211                 goto err_xa_alloc;
 212
 213         devlink->dev = dev;
 214         devlink->ops = ops;
 215         xa_init_flags(&devlink->ports, XA_FLAGS_ALLOC);
 216         xa_init_flags(&devlink->params, XA_FLAGS_ALLOC);
 217         xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
 218         write_pnet(&devlink->_net, net);
 219         INIT_LIST_HEAD(&devlink->rate_list);
 220         INIT_LIST_HEAD(&devlink->linecard_list);
 221         INIT_LIST_HEAD(&devlink->sb_list);
 222         INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
 223         INIT_LIST_HEAD(&devlink->resource_list);
 224         INIT_LIST_HEAD(&devlink->region_list);
 225         INIT_LIST_HEAD(&devlink->reporter_list);
 226         INIT_LIST_HEAD(&devlink->trap_list);
 227         INIT_LIST_HEAD(&devlink->trap_group_list);
 228         INIT_LIST_HEAD(&devlink->trap_policer_list);
 229         INIT_RCU_WORK(&devlink->rwork, devlink_release);
 230         lockdep_register_key(&devlink->lock_key);
 231         mutex_init(&devlink->lock);
 232         lockdep_set_class(&devlink->lock, &devlink->lock_key);
 233         refcount_set(&devlink->refcount, 1);
 234
 235         return devlink;
 236
 237 err_xa_alloc:
 238         kfree(devlink);
 239         return NULL;
 240 }
 241 EXPORT_SYMBOL_GPL(devlink_alloc_ns);
 242
 243 /**
 244  *      devlink_free - Free devlink instance resources
 245  *
 246  *      @devlink: devlink
 247  */
 248 void devlink_free(struct devlink *devlink)
 249 {
 250         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
 251
 252         WARN_ON(!list_empty(&devlink->trap_policer_list));
 253         WARN_ON(!list_empty(&devlink->trap_group_list));
 254         WARN_ON(!list_empty(&devlink->trap_list));
 255         WARN_ON(!list_empty(&devlink->reporter_list));
 256         WARN_ON(!list_empty(&devlink->region_list));
 257         WARN_ON(!list_empty(&devlink->resource_list));
 258         WARN_ON(!list_empty(&devlink->dpipe_table_list));
 259         WARN_ON(!list_empty(&devlink->sb_list));
 260         WARN_ON(!list_empty(&devlink->rate_list));
 261         WARN_ON(!list_empty(&devlink->linecard_list));
 262         WARN_ON(!xa_empty(&devlink->ports));
 263
 264         xa_destroy(&devlink->snapshot_ids);
 265         xa_destroy(&devlink->params);
 266         xa_destroy(&devlink->ports);
 267
 268         xa_erase(&devlinks, devlink->index);
 269
 270         devlink_put(devlink);
 271 }
 272 EXPORT_SYMBOL_GPL(devlink_free);
 273
 274 static void __net_exit devlink_pernet_pre_exit(struct net *net)
 275 {
 276         struct devlink *devlink;
 277         u32 actions_performed;
 278         unsigned long index;
 279         int err;
 280
 281         /* In case network namespace is getting destroyed, reload
 282          * all devlink instances from this namespace into init_net.
 283          */
 284         devlinks_xa_for_each_registered_get(net, index, devlink) {
 285                 devl_lock(devlink);
 286                 err = 0;
 287                 if (devl_is_registered(devlink))
 288                         err = devlink_reload(devlink, &init_net,
 289                                              DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
 290                                              DEVLINK_RELOAD_LIMIT_UNSPEC,
 291                                              &actions_performed, NULL);
 292                 devl_unlock(devlink);
 293                 devlink_put(devlink);
 294                 if (err && err != -EOPNOTSUPP)
 295                         pr_warn("Failed to reload devlink instance into init_net\n");
 296         }
 297 }
 298
 299 static struct pernet_operations devlink_pernet_ops __net_initdata = {
 300         .pre_exit = devlink_pernet_pre_exit,
 301 };
 302
 303 static struct notifier_block devlink_port_netdevice_nb = {
 304         .notifier_call = devlink_port_netdevice_event,
 305 };
 306
 307 static int __init devlink_init(void)
 308 {
 309         int err;
 310
 311         err = genl_register_family(&devlink_nl_family);
 312         if (err)
 313                 goto out;
 314         err = register_pernet_subsys(&devlink_pernet_ops);
 315         if (err)
 316                 goto out;
 317         err = register_netdevice_notifier(&devlink_port_netdevice_nb);
 318
 319 out:
 320         WARN_ON(err);
 321         return err;
 322 }
 323
 324 subsys_initcall(devlink_init);