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/rtnetlink.h>
  12 #include <linux/slab.h>
  13 #include <linux/sysfs.h>
  14
  15 #include "netdevsim.h"
  16
  17 static DEFINE_IDA(nsim_bus_dev_ids);
  18 static LIST_HEAD(nsim_bus_dev_list);
  19 static DEFINE_MUTEX(nsim_bus_dev_list_lock);
  20 static bool nsim_bus_enable;
  21
  22 static struct nsim_bus_dev *to_nsim_bus_dev(struct device *dev)
  23 {
  24         return container_of(dev, struct nsim_bus_dev, dev);
  25 }
  26
  27 static int nsim_bus_dev_vfs_enable(struct nsim_bus_dev *nsim_bus_dev,
  28                                    unsigned int num_vfs)
  29 {
  30         struct nsim_dev *nsim_dev;
  31         int err = 0;
  32
  33         if (nsim_bus_dev->max_vfs < num_vfs)
  34                 return -ENOMEM;
  35
  36         if (!nsim_bus_dev->vfconfigs)
  37                 return -ENOMEM;
  38         nsim_bus_dev->num_vfs = num_vfs;
  39
  40         nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
  41         if (nsim_esw_mode_is_switchdev(nsim_dev)) {
  42                 err = nsim_esw_switchdev_enable(nsim_dev, NULL);
  43                 if (err)
  44                         nsim_bus_dev->num_vfs = 0;
  45         }
  46
  47         return err;
  48 }
  49
  50 void nsim_bus_dev_vfs_disable(struct nsim_bus_dev *nsim_bus_dev)
  51 {
  52         struct nsim_dev *nsim_dev;
  53
  54         nsim_bus_dev->num_vfs = 0;
  55         nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
  56         if (nsim_esw_mode_is_switchdev(nsim_dev))
  57                 nsim_esw_legacy_enable(nsim_dev, NULL);
  58 }
  59
  60 static ssize_t
  61 nsim_bus_dev_numvfs_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 num_vfs;
  66         int ret;
  67
  68         ret = kstrtouint(buf, 0, &num_vfs);
  69         if (ret)
  70                 return ret;
  71
  72         mutex_lock(&nsim_bus_dev->vfs_lock);
  73         if (nsim_bus_dev->num_vfs == num_vfs)
  74                 goto exit_good;
  75         if (nsim_bus_dev->num_vfs && num_vfs) {
  76                 ret = -EBUSY;
  77                 goto exit_unlock;
  78         }
  79
  80         if (num_vfs) {
  81                 ret = nsim_bus_dev_vfs_enable(nsim_bus_dev, num_vfs);
  82                 if (ret)
  83                         goto exit_unlock;
  84         } else {
  85                 nsim_bus_dev_vfs_disable(nsim_bus_dev);
  86         }
  87 exit_good:
  88         ret = count;
  89 exit_unlock:
  90         mutex_unlock(&nsim_bus_dev->vfs_lock);
  91
  92         return ret;
  93 }
  94
  95 static ssize_t
  96 nsim_bus_dev_numvfs_show(struct device *dev,
  97                          struct device_attribute *attr, char *buf)
  98 {
  99         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 100
 101         return sprintf(buf, "%u\n", nsim_bus_dev->num_vfs);
 102 }
 103
 104 static struct device_attribute nsim_bus_dev_numvfs_attr =
 105         __ATTR(sriov_numvfs, 0664, nsim_bus_dev_numvfs_show,
 106                nsim_bus_dev_numvfs_store);
 107
 108 ssize_t nsim_bus_dev_max_vfs_read(struct file *file,
 109                                   char __user *data,
 110                                   size_t count, loff_t *ppos)
 111 {
 112         struct nsim_bus_dev *nsim_bus_dev = file->private_data;
 113         char buf[11];
 114         ssize_t len;
 115
 116         len = snprintf(buf, sizeof(buf), "%u\n", nsim_bus_dev->max_vfs);
 117         if (len < 0)
 118                 return len;
 119
 120         return simple_read_from_buffer(data, count, ppos, buf, len);
 121 }
 122
 123 ssize_t nsim_bus_dev_max_vfs_write(struct file *file,
 124                                    const char __user *data,
 125                                    size_t count, loff_t *ppos)
 126 {
 127         struct nsim_bus_dev *nsim_bus_dev = file->private_data;
 128         struct nsim_vf_config *vfconfigs;
 129         ssize_t ret;
 130         char buf[10];
 131         u32 val;
 132
 133         if (*ppos != 0)
 134                 return 0;
 135
 136         if (count >= sizeof(buf))
 137                 return -ENOSPC;
 138
 139         mutex_lock(&nsim_bus_dev->vfs_lock);
 140         /* Reject if VFs are configured */
 141         if (nsim_bus_dev->num_vfs) {
 142                 ret = -EBUSY;
 143                 goto unlock;
 144         }
 145
 146         ret = copy_from_user(buf, data, count);
 147         if (ret) {
 148                 ret = -EFAULT;
 149                 goto unlock;
 150         }
 151
 152         buf[count] = '\0';
 153         ret = kstrtouint(buf, 10, &val);
 154         if (ret) {
 155                 ret = -EIO;
 156                 goto unlock;
 157         }
 158
 159         /* max_vfs limited by the maximum number of provided port indexes */
 160         if (val > NSIM_DEV_VF_PORT_INDEX_MAX - NSIM_DEV_VF_PORT_INDEX_BASE) {
 161                 ret = -ERANGE;
 162                 goto unlock;
 163         }
 164
 165         vfconfigs = kcalloc(val, sizeof(struct nsim_vf_config), GFP_KERNEL | __GFP_NOWARN);
 166         if (!vfconfigs) {
 167                 ret = -ENOMEM;
 168                 goto unlock;
 169         }
 170
 171         kfree(nsim_bus_dev->vfconfigs);
 172         nsim_bus_dev->vfconfigs = vfconfigs;
 173         nsim_bus_dev->max_vfs = val;
 174         *ppos += count;
 175         ret = count;
 176 unlock:
 177         mutex_unlock(&nsim_bus_dev->vfs_lock);
 178         return ret;
 179 }
 180
 181 static ssize_t
 182 new_port_store(struct device *dev, struct device_attribute *attr,
 183                const char *buf, size_t count)
 184 {
 185         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 186         unsigned int port_index;
 187         int ret;
 188
 189         /* Prevent to use nsim_bus_dev before initialization. */
 190         if (!smp_load_acquire(&nsim_bus_dev->init))
 191                 return -EBUSY;
 192         ret = kstrtouint(buf, 0, &port_index);
 193         if (ret)
 194                 return ret;
 195
 196         if (!mutex_trylock(&nsim_bus_dev->nsim_bus_reload_lock))
 197                 return -EBUSY;
 198
 199         if (nsim_bus_dev->in_reload) {
 200                 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 201                 return -EBUSY;
 202         }
 203
 204         ret = nsim_dev_port_add(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index);
 205         mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 206         return ret ? ret : count;
 207 }
 208
 209 static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port);
 210
 211 static ssize_t
 212 del_port_store(struct device *dev, struct device_attribute *attr,
 213                const char *buf, size_t count)
 214 {
 215         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 216         unsigned int port_index;
 217         int ret;
 218
 219         /* Prevent to use nsim_bus_dev before initialization. */
 220         if (!smp_load_acquire(&nsim_bus_dev->init))
 221                 return -EBUSY;
 222         ret = kstrtouint(buf, 0, &port_index);
 223         if (ret)
 224                 return ret;
 225
 226         if (!mutex_trylock(&nsim_bus_dev->nsim_bus_reload_lock))
 227                 return -EBUSY;
 228
 229         if (nsim_bus_dev->in_reload) {
 230                 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 231                 return -EBUSY;
 232         }
 233
 234         ret = nsim_dev_port_del(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index);
 235         mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 236         return ret ? ret : count;
 237 }
 238
 239 static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port);
 240
 241 static struct attribute *nsim_bus_dev_attrs[] = {
 242         &nsim_bus_dev_numvfs_attr.attr,
 243         &nsim_bus_dev_new_port_attr.attr,
 244         &nsim_bus_dev_del_port_attr.attr,
 245         NULL,
 246 };
 247
 248 static const struct attribute_group nsim_bus_dev_attr_group = {
 249         .attrs = nsim_bus_dev_attrs,
 250 };
 251
 252 static const struct attribute_group *nsim_bus_dev_attr_groups[] = {
 253         &nsim_bus_dev_attr_group,
 254         NULL,
 255 };
 256
 257 static void nsim_bus_dev_release(struct device *dev)
 258 {
 259 }
 260
 261 static struct device_type nsim_bus_dev_type = {
 262         .groups = nsim_bus_dev_attr_groups,
 263         .release = nsim_bus_dev_release,
 264 };
 265
 266 static struct nsim_bus_dev *
 267 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues);
 268
 269 static ssize_t
 270 new_device_store(struct bus_type *bus, const char *buf, size_t count)
 271 {
 272         unsigned int id, port_count, num_queues;
 273         struct nsim_bus_dev *nsim_bus_dev;
 274         int err;
 275
 276         err = sscanf(buf, "%u %u %u", &id, &port_count, &num_queues);
 277         switch (err) {
 278         case 1:
 279                 port_count = 1;
 280                 fallthrough;
 281         case 2:
 282                 num_queues = 1;
 283                 fallthrough;
 284         case 3:
 285                 if (id > INT_MAX) {
 286                         pr_err("Value of \"id\" is too big.\n");
 287                         return -EINVAL;
 288                 }
 289                 break;
 290         default:
 291                 pr_err("Format for adding new device is \"id port_count num_queues\" (uint uint unit).\n");
 292                 return -EINVAL;
 293         }
 294
 295         mutex_lock(&nsim_bus_dev_list_lock);
 296         /* Prevent to use resource before initialization. */
 297         if (!smp_load_acquire(&nsim_bus_enable)) {
 298                 err = -EBUSY;
 299                 goto err;
 300         }
 301
 302         nsim_bus_dev = nsim_bus_dev_new(id, port_count, num_queues);
 303         if (IS_ERR(nsim_bus_dev)) {
 304                 err = PTR_ERR(nsim_bus_dev);
 305                 goto err;
 306         }
 307
 308         /* Allow using nsim_bus_dev */
 309         smp_store_release(&nsim_bus_dev->init, true);
 310
 311         list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list);
 312         mutex_unlock(&nsim_bus_dev_list_lock);
 313
 314         return count;
 315 err:
 316         mutex_unlock(&nsim_bus_dev_list_lock);
 317         return err;
 318 }
 319 static BUS_ATTR_WO(new_device);
 320
 321 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev);
 322
 323 static ssize_t
 324 del_device_store(struct bus_type *bus, const char *buf, size_t count)
 325 {
 326         struct nsim_bus_dev *nsim_bus_dev, *tmp;
 327         unsigned int id;
 328         int err;
 329
 330         err = sscanf(buf, "%u", &id);
 331         switch (err) {
 332         case 1:
 333                 if (id > INT_MAX) {
 334                         pr_err("Value of \"id\" is too big.\n");
 335                         return -EINVAL;
 336                 }
 337                 break;
 338         default:
 339                 pr_err("Format for deleting device is \"id\" (uint).\n");
 340                 return -EINVAL;
 341         }
 342
 343         err = -ENOENT;
 344         mutex_lock(&nsim_bus_dev_list_lock);
 345         /* Prevent to use resource before initialization. */
 346         if (!smp_load_acquire(&nsim_bus_enable)) {
 347                 mutex_unlock(&nsim_bus_dev_list_lock);
 348                 return -EBUSY;
 349         }
 350         list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
 351                 if (nsim_bus_dev->dev.id != id)
 352                         continue;
 353                 list_del(&nsim_bus_dev->list);
 354                 nsim_bus_dev_del(nsim_bus_dev);
 355                 err = 0;
 356                 break;
 357         }
 358         mutex_unlock(&nsim_bus_dev_list_lock);
 359         return !err ? count : err;
 360 }
 361 static BUS_ATTR_WO(del_device);
 362
 363 static struct attribute *nsim_bus_attrs[] = {
 364         &bus_attr_new_device.attr,
 365         &bus_attr_del_device.attr,
 366         NULL
 367 };
 368 ATTRIBUTE_GROUPS(nsim_bus);
 369
 370 static int nsim_bus_probe(struct device *dev)
 371 {
 372         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 373
 374         return nsim_dev_probe(nsim_bus_dev);
 375 }
 376
 377 static void nsim_bus_remove(struct device *dev)
 378 {
 379         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 380
 381         nsim_dev_remove(nsim_bus_dev);
 382 }
 383
 384 static int nsim_num_vf(struct device *dev)
 385 {
 386         struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
 387
 388         return nsim_bus_dev->num_vfs;
 389 }
 390
 391 static struct bus_type nsim_bus = {
 392         .name           = DRV_NAME,
 393         .dev_name       = DRV_NAME,
 394         .bus_groups     = nsim_bus_groups,
 395         .probe          = nsim_bus_probe,
 396         .remove         = nsim_bus_remove,
 397         .num_vf         = nsim_num_vf,
 398 };
 399
 400 #define NSIM_BUS_DEV_MAX_VFS 4
 401
 402 static struct nsim_bus_dev *
 403 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues)
 404 {
 405         struct nsim_bus_dev *nsim_bus_dev;
 406         int err;
 407
 408         nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL);
 409         if (!nsim_bus_dev)
 410                 return ERR_PTR(-ENOMEM);
 411
 412         err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL);
 413         if (err < 0)
 414                 goto err_nsim_bus_dev_free;
 415         nsim_bus_dev->dev.id = err;
 416         nsim_bus_dev->dev.bus = &nsim_bus;
 417         nsim_bus_dev->dev.type = &nsim_bus_dev_type;
 418         nsim_bus_dev->port_count = port_count;
 419         nsim_bus_dev->num_queues = num_queues;
 420         nsim_bus_dev->initial_net = current->nsproxy->net_ns;
 421         nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS;
 422         mutex_init(&nsim_bus_dev->nsim_bus_reload_lock);
 423         mutex_init(&nsim_bus_dev->vfs_lock);
 424         /* Disallow using nsim_bus_dev */
 425         smp_store_release(&nsim_bus_dev->init, false);
 426
 427         nsim_bus_dev->vfconfigs = kcalloc(nsim_bus_dev->max_vfs,
 428                                           sizeof(struct nsim_vf_config),
 429                                           GFP_KERNEL | __GFP_NOWARN);
 430         if (!nsim_bus_dev->vfconfigs) {
 431                 err = -ENOMEM;
 432                 goto err_nsim_bus_dev_id_free;
 433         }
 434
 435         err = device_register(&nsim_bus_dev->dev);
 436         if (err)
 437                 goto err_nsim_vfs_free;
 438
 439         return nsim_bus_dev;
 440
 441 err_nsim_vfs_free:
 442         kfree(nsim_bus_dev->vfconfigs);
 443 err_nsim_bus_dev_id_free:
 444         ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
 445 err_nsim_bus_dev_free:
 446         kfree(nsim_bus_dev);
 447         return ERR_PTR(err);
 448 }
 449
 450 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev)
 451 {
 452         /* Disallow using nsim_bus_dev */
 453         smp_store_release(&nsim_bus_dev->init, false);
 454         device_unregister(&nsim_bus_dev->dev);
 455         ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
 456         kfree(nsim_bus_dev->vfconfigs);
 457         kfree(nsim_bus_dev);
 458 }
 459
 460 static struct device_driver nsim_driver = {
 461         .name           = DRV_NAME,
 462         .bus            = &nsim_bus,
 463         .owner          = THIS_MODULE,
 464 };
 465
 466 int nsim_bus_init(void)
 467 {
 468         int err;
 469
 470         err = bus_register(&nsim_bus);
 471         if (err)
 472                 return err;
 473         err = driver_register(&nsim_driver);
 474         if (err)
 475                 goto err_bus_unregister;
 476         /* Allow using resources */
 477         smp_store_release(&nsim_bus_enable, true);
 478         return 0;
 479
 480 err_bus_unregister:
 481         bus_unregister(&nsim_bus);
 482         return err;
 483 }
 484
 485 void nsim_bus_exit(void)
 486 {
 487         struct nsim_bus_dev *nsim_bus_dev, *tmp;
 488
 489         /* Disallow using resources */
 490         smp_store_release(&nsim_bus_enable, false);
 491
 492         mutex_lock(&nsim_bus_dev_list_lock);
 493         list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
 494                 list_del(&nsim_bus_dev->list);
 495                 nsim_bus_dev_del(nsim_bus_dev);
 496         }
 497         mutex_unlock(&nsim_bus_dev_list_lock);
 498
 499         driver_unregister(&nsim_driver);
 500         bus_unregister(&nsim_bus);
 501 }