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