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