drivers/net/netdevsim/bus.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2017 Netronome Systems, Inc.
   3  * Copyright (C) 2019 Mellanox Technologies. All rights reserved
   4  */
   5
   6 #include <linux/completion.h>
   7 #include <linux/device.h>
   8 #include <linux/idr.h>
   9 #include <linux/kernel.h>
  10 #include <linux/list.h>
  11 #include <linux/mutex.h>
  12 #include <linux/refcount.h>
  13 #include <linux/slab.h>
  14 #include <linux/sysfs.h>
  15
  16 #include "netdevsim.h"
  17
  18 static DEFINE_IDA(nsim_bus_dev_ids);
  19 static LIST_HEAD(nsim_bus_dev_list);
  20 static DEFINE_MUTEX(nsim_bus_dev_list_lock);
  21 static bool nsim_bus_enable;
  22 static refcount_t nsim_bus_devs; /* Including the bus itself. */
  23 static DECLARE_COMPLETION(nsim_bus_devs_released);
  24
  25 static struct nsim_bus_dev *to_nsim_bus_dev(struct device *dev)
  26 {
  27         return container_of(dev, struct nsim_bus_dev, dev);
  28 }
  29
  30 static ssize_t
  31 nsim_bus_dev_numvfs_store(struct device *dev, struct device_attribute *attr,
  32                           const char *buf, size_t count)
  33 {
  34         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
  35         unsigned int num_vfs;
  36         int ret;
  37
  38         ret = kstrtouint(buf, 0, &num_vfs);
  39         if (ret)
  40                 return ret;
  41
  42         device_lock(dev);
  43         ret = -ENOENT;
  44         if (dev_get_drvdata(dev))
  45                 ret = nsim_drv_configure_vfs(nsim_bus_dev, num_vfs);
  46         device_unlock(dev);
  47
  48         return ret ? ret : count;
  49 }
  50
  51 static ssize_t
  52 nsim_bus_dev_numvfs_show(struct device *dev,
  53                          struct device_attribute *attr, char *buf)
  54 {
  55         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
  56
  57         return sprintf(buf, "%u\n", nsim_bus_dev->num_vfs);
  58 }
  59
  60 static struct device_attribute nsim_bus_dev_numvfs_attr =
  61         __ATTR(sriov_numvfs, 0664, nsim_bus_dev_numvfs_show,
  62                nsim_bus_dev_numvfs_store);
  63
  64 static ssize_t
  65 new_port_store(struct device *dev, struct device_attribute *attr,
  66                const char *buf, size_t count)
  67 {
  68         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
  69         unsigned int port_index;
  70         int ret;
  71
  72         /* Prevent to use nsim_bus_dev before initialization. */
  73         if (!smp_load_acquire(&nsim_bus_dev->init))
  74                 return -EBUSY;
  75         ret = kstrtouint(buf, 0, &port_index);
  76         if (ret)
  77                 return ret;
  78
  79         ret = nsim_drv_port_add(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index);
  80         return ret ? ret : count;
  81 }
  82
  83 static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port);
  84
  85 static ssize_t
  86 del_port_store(struct device *dev, struct device_attribute *attr,
  87                const char *buf, size_t count)
  88 {
  89         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
  90         unsigned int port_index;
  91         int ret;
  92
  93         /* Prevent to use nsim_bus_dev before initialization. */
  94         if (!smp_load_acquire(&nsim_bus_dev->init))
  95                 return -EBUSY;
  96         ret = kstrtouint(buf, 0, &port_index);
  97         if (ret)
  98                 return ret;
  99
 100         ret = nsim_drv_port_del(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index);
 101         return ret ? ret : count;
 102 }
 103
 104 static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port);
 105
 106 static struct attribute *nsim_bus_dev_attrs[] = {
 107         &nsim_bus_dev_numvfs_attr.attr,
 108         &nsim_bus_dev_new_port_attr.attr,
 109         &nsim_bus_dev_del_port_attr.attr,
 110         NULL,
 111 };
 112
 113 static const struct attribute_group nsim_bus_dev_attr_group = {
 114         .attrs = nsim_bus_dev_attrs,
 115 };
 116
 117 static const struct attribute_group *nsim_bus_dev_attr_groups[] = {
 118         &nsim_bus_dev_attr_group,
 119         NULL,
 120 };
 121
 122 static void nsim_bus_dev_release(struct device *dev)
 123 {
 124         struct nsim_bus_dev *nsim_bus_dev;
 125
 126         nsim_bus_dev = container_of(dev, struct nsim_bus_dev, dev);
 127         kfree(nsim_bus_dev);
 128         if (refcount_dec_and_test(&nsim_bus_devs))
 129                 complete(&nsim_bus_devs_released);
 130 }
 131
 132 static struct device_type nsim_bus_dev_type = {
 133         .groups = nsim_bus_dev_attr_groups,
 134         .release = nsim_bus_dev_release,
 135 };
 136
 137 static struct nsim_bus_dev *
 138 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues);
 139
 140 static ssize_t
 141 new_device_store(const struct bus_type *bus, const char *buf, size_t count)
 142 {
 143         unsigned int id, port_count, num_queues;
 144         struct nsim_bus_dev *nsim_bus_dev;
 145         int err;
 146
 147         err = sscanf(buf, "%u %u %u", &id, &port_count, &num_queues);
 148         switch (err) {
 149         case 1:
 150                 port_count = 1;
 151                 fallthrough;
 152         case 2:
 153                 num_queues = 1;
 154                 fallthrough;
 155         case 3:
 156                 if (id > INT_MAX) {
 157                         pr_err("Value of \"id\" is too big.\n");
 158                         return -EINVAL;
 159                 }
 160                 break;
 161         default:
 162                 pr_err("Format for adding new device is \"id port_count num_queues\" (uint uint unit).\n");
 163                 return -EINVAL;
 164         }
 165
 166         mutex_lock(&nsim_bus_dev_list_lock);
 167         /* Prevent to use resource before initialization. */
 168         if (!smp_load_acquire(&nsim_bus_enable)) {
 169                 err = -EBUSY;
 170                 goto err;
 171         }
 172
 173         nsim_bus_dev = nsim_bus_dev_new(id, port_count, num_queues);
 174         if (IS_ERR(nsim_bus_dev)) {
 175                 err = PTR_ERR(nsim_bus_dev);
 176                 goto err;
 177         }
 178
 179         refcount_inc(&nsim_bus_devs);
 180         /* Allow using nsim_bus_dev */
 181         smp_store_release(&nsim_bus_dev->init, true);
 182
 183         list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list);
 184         mutex_unlock(&nsim_bus_dev_list_lock);
 185
 186         return count;
 187 err:
 188         mutex_unlock(&nsim_bus_dev_list_lock);
 189         return err;
 190 }
 191 static BUS_ATTR_WO(new_device);
 192
 193 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev);
 194
 195 static ssize_t
 196 del_device_store(const struct bus_type *bus, const char *buf, size_t count)
 197 {
 198         struct nsim_bus_dev *nsim_bus_dev, *tmp;
 199         unsigned int id;
 200         int err;
 201
 202         err = sscanf(buf, "%u", &id);
 203         switch (err) {
 204         case 1:
 205                 if (id > INT_MAX) {
 206                         pr_err("Value of \"id\" is too big.\n");
 207                         return -EINVAL;
 208                 }
 209                 break;
 210         default:
 211                 pr_err("Format for deleting device is \"id\" (uint).\n");
 212                 return -EINVAL;
 213         }
 214
 215         err = -ENOENT;
 216         mutex_lock(&nsim_bus_dev_list_lock);
 217         /* Prevent to use resource before initialization. */
 218         if (!smp_load_acquire(&nsim_bus_enable)) {
 219                 mutex_unlock(&nsim_bus_dev_list_lock);
 220                 return -EBUSY;
 221         }
 222         list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
 223                 if (nsim_bus_dev->dev.id != id)
 224                         continue;
 225                 list_del(&nsim_bus_dev->list);
 226                 nsim_bus_dev_del(nsim_bus_dev);
 227                 err = 0;
 228                 break;
 229         }
 230         mutex_unlock(&nsim_bus_dev_list_lock);
 231         return !err ? count : err;
 232 }
 233 static BUS_ATTR_WO(del_device);
 234
 235 static struct attribute *nsim_bus_attrs[] = {
 236         &bus_attr_new_device.attr,
 237         &bus_attr_del_device.attr,
 238         NULL
 239 };
 240 ATTRIBUTE_GROUPS(nsim_bus);
 241
 242 static int nsim_bus_probe(struct device *dev)
 243 {
 244         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 245
 246         return nsim_drv_probe(nsim_bus_dev);
 247 }
 248
 249 static void nsim_bus_remove(struct device *dev)
 250 {
 251         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 252
 253         nsim_drv_remove(nsim_bus_dev);
 254 }
 255
 256 static int nsim_num_vf(struct device *dev)
 257 {
 258         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 259
 260         return nsim_bus_dev->num_vfs;
 261 }
 262
 263 static struct bus_type nsim_bus = {
 264         .name           = DRV_NAME,
 265         .dev_name       = DRV_NAME,
 266         .bus_groups     = nsim_bus_groups,
 267         .probe          = nsim_bus_probe,
 268         .remove         = nsim_bus_remove,
 269         .num_vf         = nsim_num_vf,
 270 };
 271
 272 #define NSIM_BUS_DEV_MAX_VFS 4
 273
 274 static struct nsim_bus_dev *
 275 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues)
 276 {
 277         struct nsim_bus_dev *nsim_bus_dev;
 278         int err;
 279
 280         nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL);
 281         if (!nsim_bus_dev)
 282                 return ERR_PTR(-ENOMEM);
 283
 284         err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL);
 285         if (err < 0)
 286                 goto err_nsim_bus_dev_free;
 287         nsim_bus_dev->dev.id = err;
 288         nsim_bus_dev->dev.bus = &nsim_bus;
 289         nsim_bus_dev->dev.type = &nsim_bus_dev_type;
 290         nsim_bus_dev->port_count = port_count;
 291         nsim_bus_dev->num_queues = num_queues;
 292         nsim_bus_dev->initial_net = current->nsproxy->net_ns;
 293         nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS;
 294         /* Disallow using nsim_bus_dev */
 295         smp_store_release(&nsim_bus_dev->init, false);
 296
 297         err = device_register(&nsim_bus_dev->dev);
 298         if (err)
 299                 goto err_nsim_bus_dev_id_free;
 300
 301         return nsim_bus_dev;
 302
 303 err_nsim_bus_dev_id_free:
 304         ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
 305         put_device(&nsim_bus_dev->dev);
 306         nsim_bus_dev = NULL;
 307 err_nsim_bus_dev_free:
 308         kfree(nsim_bus_dev);
 309         return ERR_PTR(err);
 310 }
 311
 312 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev)
 313 {
 314         /* Disallow using nsim_bus_dev */
 315         smp_store_release(&nsim_bus_dev->init, false);
 316         ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
 317         device_unregister(&nsim_bus_dev->dev);
 318 }
 319
 320 static struct device_driver nsim_driver = {
 321         .name           = DRV_NAME,
 322         .bus            = &nsim_bus,
 323         .owner          = THIS_MODULE,
 324 };
 325
 326 int nsim_bus_init(void)
 327 {
 328         int err;
 329
 330         err = bus_register(&nsim_bus);
 331         if (err)
 332                 return err;
 333         err = driver_register(&nsim_driver);
 334         if (err)
 335                 goto err_bus_unregister;
 336         refcount_set(&nsim_bus_devs, 1);
 337         /* Allow using resources */
 338         smp_store_release(&nsim_bus_enable, true);
 339         return 0;
 340
 341 err_bus_unregister:
 342         bus_unregister(&nsim_bus);
 343         return err;
 344 }
 345
 346 void nsim_bus_exit(void)
 347 {
 348         struct nsim_bus_dev *nsim_bus_dev, *tmp;
 349
 350         /* Disallow using resources */
 351         smp_store_release(&nsim_bus_enable, false);
 352         if (refcount_dec_and_test(&nsim_bus_devs))
 353                 complete(&nsim_bus_devs_released);
 354
 355         mutex_lock(&nsim_bus_dev_list_lock);
 356         list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
 357                 list_del(&nsim_bus_dev->list);
 358                 nsim_bus_dev_del(nsim_bus_dev);
 359         }
 360         mutex_unlock(&nsim_bus_dev_list_lock);
 361
 362         wait_for_completion(&nsim_bus_devs_released);
 363
 364         driver_unregister(&nsim_driver);
 365         bus_unregister(&nsim_bus);
 366 }