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 ret = nsim_dev_port_add(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index); 200 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock); 201 return ret ? ret : count; 202 } 203 204 static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port); 205 206 static ssize_t 207 del_port_store(struct device *dev, struct device_attribute *attr, 208 const char *buf, size_t count) 209 { 210 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 211 unsigned int port_index; 212 int ret; 213 214 /* Prevent to use nsim_bus_dev before initialization. */ 215 if (!smp_load_acquire(&nsim_bus_dev->init)) 216 return -EBUSY; 217 ret = kstrtouint(buf, 0, &port_index); 218 if (ret) 219 return ret; 220 221 if (!mutex_trylock(&nsim_bus_dev->nsim_bus_reload_lock)) 222 return -EBUSY; 223 224 ret = nsim_dev_port_del(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index); 225 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock); 226 return ret ? ret : count; 227 } 228 229 static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port); 230 231 static struct attribute *nsim_bus_dev_attrs[] = { 232 &nsim_bus_dev_numvfs_attr.attr, 233 &nsim_bus_dev_new_port_attr.attr, 234 &nsim_bus_dev_del_port_attr.attr, 235 NULL, 236 }; 237 238 static const struct attribute_group nsim_bus_dev_attr_group = { 239 .attrs = nsim_bus_dev_attrs, 240 }; 241 242 static const struct attribute_group *nsim_bus_dev_attr_groups[] = { 243 &nsim_bus_dev_attr_group, 244 NULL, 245 }; 246 247 static void nsim_bus_dev_release(struct device *dev) 248 { 249 } 250 251 static struct device_type nsim_bus_dev_type = { 252 .groups = nsim_bus_dev_attr_groups, 253 .release = nsim_bus_dev_release, 254 }; 255 256 static struct nsim_bus_dev * 257 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues); 258 259 static ssize_t 260 new_device_store(struct bus_type *bus, const char *buf, size_t count) 261 { 262 unsigned int id, port_count, num_queues; 263 struct nsim_bus_dev *nsim_bus_dev; 264 int err; 265 266 err = sscanf(buf, "%u %u %u", &id, &port_count, &num_queues); 267 switch (err) { 268 case 1: 269 port_count = 1; 270 fallthrough; 271 case 2: 272 num_queues = 1; 273 fallthrough; 274 case 3: 275 if (id > INT_MAX) { 276 pr_err("Value of \"id\" is too big.\n"); 277 return -EINVAL; 278 } 279 break; 280 default: 281 pr_err("Format for adding new device is \"id port_count num_queues\" (uint uint unit).\n"); 282 return -EINVAL; 283 } 284 285 mutex_lock(&nsim_bus_dev_list_lock); 286 /* Prevent to use resource before initialization. */ 287 if (!smp_load_acquire(&nsim_bus_enable)) { 288 err = -EBUSY; 289 goto err; 290 } 291 292 nsim_bus_dev = nsim_bus_dev_new(id, port_count, num_queues); 293 if (IS_ERR(nsim_bus_dev)) { 294 err = PTR_ERR(nsim_bus_dev); 295 goto err; 296 } 297 298 /* Allow using nsim_bus_dev */ 299 smp_store_release(&nsim_bus_dev->init, true); 300 301 list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list); 302 mutex_unlock(&nsim_bus_dev_list_lock); 303 304 return count; 305 err: 306 mutex_unlock(&nsim_bus_dev_list_lock); 307 return err; 308 } 309 static BUS_ATTR_WO(new_device); 310 311 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev); 312 313 static ssize_t 314 del_device_store(struct bus_type *bus, const char *buf, size_t count) 315 { 316 struct nsim_bus_dev *nsim_bus_dev, *tmp; 317 unsigned int id; 318 int err; 319 320 err = sscanf(buf, "%u", &id); 321 switch (err) { 322 case 1: 323 if (id > INT_MAX) { 324 pr_err("Value of \"id\" is too big.\n"); 325 return -EINVAL; 326 } 327 break; 328 default: 329 pr_err("Format for deleting device is \"id\" (uint).\n"); 330 return -EINVAL; 331 } 332 333 err = -ENOENT; 334 mutex_lock(&nsim_bus_dev_list_lock); 335 /* Prevent to use resource before initialization. */ 336 if (!smp_load_acquire(&nsim_bus_enable)) { 337 mutex_unlock(&nsim_bus_dev_list_lock); 338 return -EBUSY; 339 } 340 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 341 if (nsim_bus_dev->dev.id != id) 342 continue; 343 list_del(&nsim_bus_dev->list); 344 nsim_bus_dev_del(nsim_bus_dev); 345 err = 0; 346 break; 347 } 348 mutex_unlock(&nsim_bus_dev_list_lock); 349 return !err ? count : err; 350 } 351 static BUS_ATTR_WO(del_device); 352 353 static struct attribute *nsim_bus_attrs[] = { 354 &bus_attr_new_device.attr, 355 &bus_attr_del_device.attr, 356 NULL 357 }; 358 ATTRIBUTE_GROUPS(nsim_bus); 359 360 static int nsim_bus_probe(struct device *dev) 361 { 362 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 363 364 return nsim_dev_probe(nsim_bus_dev); 365 } 366 367 static int nsim_bus_remove(struct device *dev) 368 { 369 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 370 371 nsim_dev_remove(nsim_bus_dev); 372 return 0; 373 } 374 375 static int nsim_num_vf(struct device *dev) 376 { 377 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 378 379 return nsim_bus_dev->num_vfs; 380 } 381 382 static struct bus_type nsim_bus = { 383 .name = DRV_NAME, 384 .dev_name = DRV_NAME, 385 .bus_groups = nsim_bus_groups, 386 .probe = nsim_bus_probe, 387 .remove = nsim_bus_remove, 388 .num_vf = nsim_num_vf, 389 }; 390 391 #define NSIM_BUS_DEV_MAX_VFS 4 392 393 static struct nsim_bus_dev * 394 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues) 395 { 396 struct nsim_bus_dev *nsim_bus_dev; 397 int err; 398 399 nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL); 400 if (!nsim_bus_dev) 401 return ERR_PTR(-ENOMEM); 402 403 err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL); 404 if (err < 0) 405 goto err_nsim_bus_dev_free; 406 nsim_bus_dev->dev.id = err; 407 nsim_bus_dev->dev.bus = &nsim_bus; 408 nsim_bus_dev->dev.type = &nsim_bus_dev_type; 409 nsim_bus_dev->port_count = port_count; 410 nsim_bus_dev->num_queues = num_queues; 411 nsim_bus_dev->initial_net = current->nsproxy->net_ns; 412 nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS; 413 mutex_init(&nsim_bus_dev->nsim_bus_reload_lock); 414 mutex_init(&nsim_bus_dev->vfs_lock); 415 /* Disallow using nsim_bus_dev */ 416 smp_store_release(&nsim_bus_dev->init, false); 417 418 nsim_bus_dev->vfconfigs = kcalloc(nsim_bus_dev->max_vfs, 419 sizeof(struct nsim_vf_config), 420 GFP_KERNEL | __GFP_NOWARN); 421 if (!nsim_bus_dev->vfconfigs) { 422 err = -ENOMEM; 423 goto err_nsim_bus_dev_id_free; 424 } 425 426 err = device_register(&nsim_bus_dev->dev); 427 if (err) 428 goto err_nsim_vfs_free; 429 430 return nsim_bus_dev; 431 432 err_nsim_vfs_free: 433 kfree(nsim_bus_dev->vfconfigs); 434 err_nsim_bus_dev_id_free: 435 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 436 err_nsim_bus_dev_free: 437 kfree(nsim_bus_dev); 438 return ERR_PTR(err); 439 } 440 441 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev) 442 { 443 /* Disallow using nsim_bus_dev */ 444 smp_store_release(&nsim_bus_dev->init, false); 445 device_unregister(&nsim_bus_dev->dev); 446 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 447 kfree(nsim_bus_dev->vfconfigs); 448 kfree(nsim_bus_dev); 449 } 450 451 static struct device_driver nsim_driver = { 452 .name = DRV_NAME, 453 .bus = &nsim_bus, 454 .owner = THIS_MODULE, 455 }; 456 457 int nsim_bus_init(void) 458 { 459 int err; 460 461 err = bus_register(&nsim_bus); 462 if (err) 463 return err; 464 err = driver_register(&nsim_driver); 465 if (err) 466 goto err_bus_unregister; 467 /* Allow using resources */ 468 smp_store_release(&nsim_bus_enable, true); 469 return 0; 470 471 err_bus_unregister: 472 bus_unregister(&nsim_bus); 473 return err; 474 } 475 476 void nsim_bus_exit(void) 477 { 478 struct nsim_bus_dev *nsim_bus_dev, *tmp; 479 480 /* Disallow using resources */ 481 smp_store_release(&nsim_bus_enable, false); 482 483 mutex_lock(&nsim_bus_dev_list_lock); 484 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 485 list_del(&nsim_bus_dev->list); 486 nsim_bus_dev_del(nsim_bus_dev); 487 } 488 mutex_unlock(&nsim_bus_dev_list_lock); 489 490 driver_unregister(&nsim_driver); 491 bus_unregister(&nsim_bus); 492 } 493