1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * vDPA bus. 4 * 5 * Copyright (c) 2020, Red Hat. All rights reserved. 6 * Author: Jason Wang <jasowang@redhat.com> 7 * 8 */ 9 10 #include <linux/module.h> 11 #include <linux/idr.h> 12 #include <linux/slab.h> 13 #include <linux/vdpa.h> 14 #include <uapi/linux/vdpa.h> 15 #include <net/genetlink.h> 16 #include <linux/mod_devicetable.h> 17 #include <linux/virtio_ids.h> 18 19 static LIST_HEAD(mdev_head); 20 /* A global mutex that protects vdpa management device and device level operations. */ 21 static DEFINE_MUTEX(vdpa_dev_mutex); 22 static DEFINE_IDA(vdpa_index_ida); 23 24 static struct genl_family vdpa_nl_family; 25 26 static int vdpa_dev_probe(struct device *d) 27 { 28 struct vdpa_device *vdev = dev_to_vdpa(d); 29 struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver); 30 const struct vdpa_config_ops *ops = vdev->config; 31 u32 max_num, min_num = 1; 32 int ret = 0; 33 34 max_num = ops->get_vq_num_max(vdev); 35 if (ops->get_vq_num_min) 36 min_num = ops->get_vq_num_min(vdev); 37 if (max_num < min_num) 38 return -EINVAL; 39 40 if (drv && drv->probe) 41 ret = drv->probe(vdev); 42 43 return ret; 44 } 45 46 static void vdpa_dev_remove(struct device *d) 47 { 48 struct vdpa_device *vdev = dev_to_vdpa(d); 49 struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver); 50 51 if (drv && drv->remove) 52 drv->remove(vdev); 53 } 54 55 static struct bus_type vdpa_bus = { 56 .name = "vdpa", 57 .probe = vdpa_dev_probe, 58 .remove = vdpa_dev_remove, 59 }; 60 61 static void vdpa_release_dev(struct device *d) 62 { 63 struct vdpa_device *vdev = dev_to_vdpa(d); 64 const struct vdpa_config_ops *ops = vdev->config; 65 66 if (ops->free) 67 ops->free(vdev); 68 69 ida_simple_remove(&vdpa_index_ida, vdev->index); 70 mutex_destroy(&vdev->cf_mutex); 71 kfree(vdev); 72 } 73 74 /** 75 * __vdpa_alloc_device - allocate and initilaize a vDPA device 76 * This allows driver to some prepartion after device is 77 * initialized but before registered. 78 * @parent: the parent device 79 * @config: the bus operations that is supported by this device 80 * @size: size of the parent structure that contains private data 81 * @name: name of the vdpa device; optional. 82 * @use_va: indicate whether virtual address must be used by this device 83 * 84 * Driver should use vdpa_alloc_device() wrapper macro instead of 85 * using this directly. 86 * 87 * Return: Returns an error when parent/config/dma_dev is not set or fail to get 88 * ida. 89 */ 90 struct vdpa_device *__vdpa_alloc_device(struct device *parent, 91 const struct vdpa_config_ops *config, 92 size_t size, const char *name, 93 bool use_va) 94 { 95 struct vdpa_device *vdev; 96 int err = -EINVAL; 97 98 if (!config) 99 goto err; 100 101 if (!!config->dma_map != !!config->dma_unmap) 102 goto err; 103 104 /* It should only work for the device that use on-chip IOMMU */ 105 if (use_va && !(config->dma_map || config->set_map)) 106 goto err; 107 108 err = -ENOMEM; 109 vdev = kzalloc(size, GFP_KERNEL); 110 if (!vdev) 111 goto err; 112 113 err = ida_alloc(&vdpa_index_ida, GFP_KERNEL); 114 if (err < 0) 115 goto err_ida; 116 117 vdev->dev.bus = &vdpa_bus; 118 vdev->dev.parent = parent; 119 vdev->dev.release = vdpa_release_dev; 120 vdev->index = err; 121 vdev->config = config; 122 vdev->features_valid = false; 123 vdev->use_va = use_va; 124 125 if (name) 126 err = dev_set_name(&vdev->dev, "%s", name); 127 else 128 err = dev_set_name(&vdev->dev, "vdpa%u", vdev->index); 129 if (err) 130 goto err_name; 131 132 mutex_init(&vdev->cf_mutex); 133 device_initialize(&vdev->dev); 134 135 return vdev; 136 137 err_name: 138 ida_simple_remove(&vdpa_index_ida, vdev->index); 139 err_ida: 140 kfree(vdev); 141 err: 142 return ERR_PTR(err); 143 } 144 EXPORT_SYMBOL_GPL(__vdpa_alloc_device); 145 146 static int vdpa_name_match(struct device *dev, const void *data) 147 { 148 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev); 149 150 return (strcmp(dev_name(&vdev->dev), data) == 0); 151 } 152 153 static int __vdpa_register_device(struct vdpa_device *vdev, int nvqs) 154 { 155 struct device *dev; 156 157 vdev->nvqs = nvqs; 158 159 lockdep_assert_held(&vdpa_dev_mutex); 160 dev = bus_find_device(&vdpa_bus, NULL, dev_name(&vdev->dev), vdpa_name_match); 161 if (dev) { 162 put_device(dev); 163 return -EEXIST; 164 } 165 return device_add(&vdev->dev); 166 } 167 168 /** 169 * _vdpa_register_device - register a vDPA device with vdpa lock held 170 * Caller must have a succeed call of vdpa_alloc_device() before. 171 * Caller must invoke this routine in the management device dev_add() 172 * callback after setting up valid mgmtdev for this vdpa device. 173 * @vdev: the vdpa device to be registered to vDPA bus 174 * @nvqs: number of virtqueues supported by this device 175 * 176 * Return: Returns an error when fail to add device to vDPA bus 177 */ 178 int _vdpa_register_device(struct vdpa_device *vdev, int nvqs) 179 { 180 if (!vdev->mdev) 181 return -EINVAL; 182 183 return __vdpa_register_device(vdev, nvqs); 184 } 185 EXPORT_SYMBOL_GPL(_vdpa_register_device); 186 187 /** 188 * vdpa_register_device - register a vDPA device 189 * Callers must have a succeed call of vdpa_alloc_device() before. 190 * @vdev: the vdpa device to be registered to vDPA bus 191 * @nvqs: number of virtqueues supported by this device 192 * 193 * Return: Returns an error when fail to add to vDPA bus 194 */ 195 int vdpa_register_device(struct vdpa_device *vdev, int nvqs) 196 { 197 int err; 198 199 mutex_lock(&vdpa_dev_mutex); 200 err = __vdpa_register_device(vdev, nvqs); 201 mutex_unlock(&vdpa_dev_mutex); 202 return err; 203 } 204 EXPORT_SYMBOL_GPL(vdpa_register_device); 205 206 /** 207 * _vdpa_unregister_device - unregister a vDPA device 208 * Caller must invoke this routine as part of management device dev_del() 209 * callback. 210 * @vdev: the vdpa device to be unregisted from vDPA bus 211 */ 212 void _vdpa_unregister_device(struct vdpa_device *vdev) 213 { 214 lockdep_assert_held(&vdpa_dev_mutex); 215 WARN_ON(!vdev->mdev); 216 device_unregister(&vdev->dev); 217 } 218 EXPORT_SYMBOL_GPL(_vdpa_unregister_device); 219 220 /** 221 * vdpa_unregister_device - unregister a vDPA device 222 * @vdev: the vdpa device to be unregisted from vDPA bus 223 */ 224 void vdpa_unregister_device(struct vdpa_device *vdev) 225 { 226 mutex_lock(&vdpa_dev_mutex); 227 device_unregister(&vdev->dev); 228 mutex_unlock(&vdpa_dev_mutex); 229 } 230 EXPORT_SYMBOL_GPL(vdpa_unregister_device); 231 232 /** 233 * __vdpa_register_driver - register a vDPA device driver 234 * @drv: the vdpa device driver to be registered 235 * @owner: module owner of the driver 236 * 237 * Return: Returns an err when fail to do the registration 238 */ 239 int __vdpa_register_driver(struct vdpa_driver *drv, struct module *owner) 240 { 241 drv->driver.bus = &vdpa_bus; 242 drv->driver.owner = owner; 243 244 return driver_register(&drv->driver); 245 } 246 EXPORT_SYMBOL_GPL(__vdpa_register_driver); 247 248 /** 249 * vdpa_unregister_driver - unregister a vDPA device driver 250 * @drv: the vdpa device driver to be unregistered 251 */ 252 void vdpa_unregister_driver(struct vdpa_driver *drv) 253 { 254 driver_unregister(&drv->driver); 255 } 256 EXPORT_SYMBOL_GPL(vdpa_unregister_driver); 257 258 /** 259 * vdpa_mgmtdev_register - register a vdpa management device 260 * 261 * @mdev: Pointer to vdpa management device 262 * vdpa_mgmtdev_register() register a vdpa management device which supports 263 * vdpa device management. 264 * Return: Returns 0 on success or failure when required callback ops are not 265 * initialized. 266 */ 267 int vdpa_mgmtdev_register(struct vdpa_mgmt_dev *mdev) 268 { 269 if (!mdev->device || !mdev->ops || !mdev->ops->dev_add || !mdev->ops->dev_del) 270 return -EINVAL; 271 272 INIT_LIST_HEAD(&mdev->list); 273 mutex_lock(&vdpa_dev_mutex); 274 list_add_tail(&mdev->list, &mdev_head); 275 mutex_unlock(&vdpa_dev_mutex); 276 return 0; 277 } 278 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_register); 279 280 static int vdpa_match_remove(struct device *dev, void *data) 281 { 282 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev); 283 struct vdpa_mgmt_dev *mdev = vdev->mdev; 284 285 if (mdev == data) 286 mdev->ops->dev_del(mdev, vdev); 287 return 0; 288 } 289 290 void vdpa_mgmtdev_unregister(struct vdpa_mgmt_dev *mdev) 291 { 292 mutex_lock(&vdpa_dev_mutex); 293 294 list_del(&mdev->list); 295 296 /* Filter out all the entries belong to this management device and delete it. */ 297 bus_for_each_dev(&vdpa_bus, NULL, mdev, vdpa_match_remove); 298 299 mutex_unlock(&vdpa_dev_mutex); 300 } 301 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_unregister); 302 303 /** 304 * vdpa_get_config - Get one or more device configuration fields. 305 * @vdev: vdpa device to operate on 306 * @offset: starting byte offset of the field 307 * @buf: buffer pointer to read to 308 * @len: length of the configuration fields in bytes 309 */ 310 void vdpa_get_config(struct vdpa_device *vdev, unsigned int offset, 311 void *buf, unsigned int len) 312 { 313 const struct vdpa_config_ops *ops = vdev->config; 314 315 mutex_lock(&vdev->cf_mutex); 316 /* 317 * Config accesses aren't supposed to trigger before features are set. 318 * If it does happen we assume a legacy guest. 319 */ 320 if (!vdev->features_valid) 321 vdpa_set_features(vdev, 0); 322 ops->get_config(vdev, offset, buf, len); 323 mutex_unlock(&vdev->cf_mutex); 324 } 325 EXPORT_SYMBOL_GPL(vdpa_get_config); 326 327 /** 328 * vdpa_set_config - Set one or more device configuration fields. 329 * @vdev: vdpa device to operate on 330 * @offset: starting byte offset of the field 331 * @buf: buffer pointer to read from 332 * @length: length of the configuration fields in bytes 333 */ 334 void vdpa_set_config(struct vdpa_device *vdev, unsigned int offset, 335 const void *buf, unsigned int length) 336 { 337 mutex_lock(&vdev->cf_mutex); 338 vdev->config->set_config(vdev, offset, buf, length); 339 mutex_unlock(&vdev->cf_mutex); 340 } 341 EXPORT_SYMBOL_GPL(vdpa_set_config); 342 343 static bool mgmtdev_handle_match(const struct vdpa_mgmt_dev *mdev, 344 const char *busname, const char *devname) 345 { 346 /* Bus name is optional for simulated management device, so ignore the 347 * device with bus if bus attribute is provided. 348 */ 349 if ((busname && !mdev->device->bus) || (!busname && mdev->device->bus)) 350 return false; 351 352 if (!busname && strcmp(dev_name(mdev->device), devname) == 0) 353 return true; 354 355 if (busname && (strcmp(mdev->device->bus->name, busname) == 0) && 356 (strcmp(dev_name(mdev->device), devname) == 0)) 357 return true; 358 359 return false; 360 } 361 362 static struct vdpa_mgmt_dev *vdpa_mgmtdev_get_from_attr(struct nlattr **attrs) 363 { 364 struct vdpa_mgmt_dev *mdev; 365 const char *busname = NULL; 366 const char *devname; 367 368 if (!attrs[VDPA_ATTR_MGMTDEV_DEV_NAME]) 369 return ERR_PTR(-EINVAL); 370 devname = nla_data(attrs[VDPA_ATTR_MGMTDEV_DEV_NAME]); 371 if (attrs[VDPA_ATTR_MGMTDEV_BUS_NAME]) 372 busname = nla_data(attrs[VDPA_ATTR_MGMTDEV_BUS_NAME]); 373 374 list_for_each_entry(mdev, &mdev_head, list) { 375 if (mgmtdev_handle_match(mdev, busname, devname)) 376 return mdev; 377 } 378 return ERR_PTR(-ENODEV); 379 } 380 381 static int vdpa_nl_mgmtdev_handle_fill(struct sk_buff *msg, const struct vdpa_mgmt_dev *mdev) 382 { 383 if (mdev->device->bus && 384 nla_put_string(msg, VDPA_ATTR_MGMTDEV_BUS_NAME, mdev->device->bus->name)) 385 return -EMSGSIZE; 386 if (nla_put_string(msg, VDPA_ATTR_MGMTDEV_DEV_NAME, dev_name(mdev->device))) 387 return -EMSGSIZE; 388 return 0; 389 } 390 391 static int vdpa_mgmtdev_fill(const struct vdpa_mgmt_dev *mdev, struct sk_buff *msg, 392 u32 portid, u32 seq, int flags) 393 { 394 u64 supported_classes = 0; 395 void *hdr; 396 int i = 0; 397 int err; 398 399 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_MGMTDEV_NEW); 400 if (!hdr) 401 return -EMSGSIZE; 402 err = vdpa_nl_mgmtdev_handle_fill(msg, mdev); 403 if (err) 404 goto msg_err; 405 406 while (mdev->id_table[i].device) { 407 if (mdev->id_table[i].device <= 63) 408 supported_classes |= BIT_ULL(mdev->id_table[i].device); 409 i++; 410 } 411 412 if (nla_put_u64_64bit(msg, VDPA_ATTR_MGMTDEV_SUPPORTED_CLASSES, 413 supported_classes, VDPA_ATTR_UNSPEC)) { 414 err = -EMSGSIZE; 415 goto msg_err; 416 } 417 418 genlmsg_end(msg, hdr); 419 return 0; 420 421 msg_err: 422 genlmsg_cancel(msg, hdr); 423 return err; 424 } 425 426 static int vdpa_nl_cmd_mgmtdev_get_doit(struct sk_buff *skb, struct genl_info *info) 427 { 428 struct vdpa_mgmt_dev *mdev; 429 struct sk_buff *msg; 430 int err; 431 432 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 433 if (!msg) 434 return -ENOMEM; 435 436 mutex_lock(&vdpa_dev_mutex); 437 mdev = vdpa_mgmtdev_get_from_attr(info->attrs); 438 if (IS_ERR(mdev)) { 439 mutex_unlock(&vdpa_dev_mutex); 440 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified mgmt device"); 441 err = PTR_ERR(mdev); 442 goto out; 443 } 444 445 err = vdpa_mgmtdev_fill(mdev, msg, info->snd_portid, info->snd_seq, 0); 446 mutex_unlock(&vdpa_dev_mutex); 447 if (err) 448 goto out; 449 err = genlmsg_reply(msg, info); 450 return err; 451 452 out: 453 nlmsg_free(msg); 454 return err; 455 } 456 457 static int 458 vdpa_nl_cmd_mgmtdev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb) 459 { 460 struct vdpa_mgmt_dev *mdev; 461 int start = cb->args[0]; 462 int idx = 0; 463 int err; 464 465 mutex_lock(&vdpa_dev_mutex); 466 list_for_each_entry(mdev, &mdev_head, list) { 467 if (idx < start) { 468 idx++; 469 continue; 470 } 471 err = vdpa_mgmtdev_fill(mdev, msg, NETLINK_CB(cb->skb).portid, 472 cb->nlh->nlmsg_seq, NLM_F_MULTI); 473 if (err) 474 goto out; 475 idx++; 476 } 477 out: 478 mutex_unlock(&vdpa_dev_mutex); 479 cb->args[0] = idx; 480 return msg->len; 481 } 482 483 #define VDPA_DEV_NET_ATTRS_MASK ((1 << VDPA_ATTR_DEV_NET_CFG_MACADDR) | \ 484 (1 << VDPA_ATTR_DEV_NET_CFG_MTU)) 485 486 static int vdpa_nl_cmd_dev_add_set_doit(struct sk_buff *skb, struct genl_info *info) 487 { 488 struct vdpa_dev_set_config config = {}; 489 struct nlattr **nl_attrs = info->attrs; 490 struct vdpa_mgmt_dev *mdev; 491 const u8 *macaddr; 492 const char *name; 493 int err = 0; 494 495 if (!info->attrs[VDPA_ATTR_DEV_NAME]) 496 return -EINVAL; 497 498 name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]); 499 500 if (nl_attrs[VDPA_ATTR_DEV_NET_CFG_MACADDR]) { 501 macaddr = nla_data(nl_attrs[VDPA_ATTR_DEV_NET_CFG_MACADDR]); 502 memcpy(config.net.mac, macaddr, sizeof(config.net.mac)); 503 config.mask |= (1 << VDPA_ATTR_DEV_NET_CFG_MACADDR); 504 } 505 if (nl_attrs[VDPA_ATTR_DEV_NET_CFG_MTU]) { 506 config.net.mtu = 507 nla_get_u16(nl_attrs[VDPA_ATTR_DEV_NET_CFG_MTU]); 508 config.mask |= (1 << VDPA_ATTR_DEV_NET_CFG_MTU); 509 } 510 511 /* Skip checking capability if user didn't prefer to configure any 512 * device networking attributes. It is likely that user might have used 513 * a device specific method to configure such attributes or using device 514 * default attributes. 515 */ 516 if ((config.mask & VDPA_DEV_NET_ATTRS_MASK) && 517 !netlink_capable(skb, CAP_NET_ADMIN)) 518 return -EPERM; 519 520 mutex_lock(&vdpa_dev_mutex); 521 mdev = vdpa_mgmtdev_get_from_attr(info->attrs); 522 if (IS_ERR(mdev)) { 523 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified management device"); 524 err = PTR_ERR(mdev); 525 goto err; 526 } 527 if ((config.mask & mdev->config_attr_mask) != config.mask) { 528 NL_SET_ERR_MSG_MOD(info->extack, 529 "All provided attributes are not supported"); 530 err = -EOPNOTSUPP; 531 goto err; 532 } 533 534 err = mdev->ops->dev_add(mdev, name, &config); 535 err: 536 mutex_unlock(&vdpa_dev_mutex); 537 return err; 538 } 539 540 static int vdpa_nl_cmd_dev_del_set_doit(struct sk_buff *skb, struct genl_info *info) 541 { 542 struct vdpa_mgmt_dev *mdev; 543 struct vdpa_device *vdev; 544 struct device *dev; 545 const char *name; 546 int err = 0; 547 548 if (!info->attrs[VDPA_ATTR_DEV_NAME]) 549 return -EINVAL; 550 name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]); 551 552 mutex_lock(&vdpa_dev_mutex); 553 dev = bus_find_device(&vdpa_bus, NULL, name, vdpa_name_match); 554 if (!dev) { 555 NL_SET_ERR_MSG_MOD(info->extack, "device not found"); 556 err = -ENODEV; 557 goto dev_err; 558 } 559 vdev = container_of(dev, struct vdpa_device, dev); 560 if (!vdev->mdev) { 561 NL_SET_ERR_MSG_MOD(info->extack, "Only user created device can be deleted by user"); 562 err = -EINVAL; 563 goto mdev_err; 564 } 565 mdev = vdev->mdev; 566 mdev->ops->dev_del(mdev, vdev); 567 mdev_err: 568 put_device(dev); 569 dev_err: 570 mutex_unlock(&vdpa_dev_mutex); 571 return err; 572 } 573 574 static int 575 vdpa_dev_fill(struct vdpa_device *vdev, struct sk_buff *msg, u32 portid, u32 seq, 576 int flags, struct netlink_ext_ack *extack) 577 { 578 u16 max_vq_size; 579 u16 min_vq_size = 1; 580 u32 device_id; 581 u32 vendor_id; 582 void *hdr; 583 int err; 584 585 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_DEV_NEW); 586 if (!hdr) 587 return -EMSGSIZE; 588 589 err = vdpa_nl_mgmtdev_handle_fill(msg, vdev->mdev); 590 if (err) 591 goto msg_err; 592 593 device_id = vdev->config->get_device_id(vdev); 594 vendor_id = vdev->config->get_vendor_id(vdev); 595 max_vq_size = vdev->config->get_vq_num_max(vdev); 596 if (vdev->config->get_vq_num_min) 597 min_vq_size = vdev->config->get_vq_num_min(vdev); 598 599 err = -EMSGSIZE; 600 if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev))) 601 goto msg_err; 602 if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id)) 603 goto msg_err; 604 if (nla_put_u32(msg, VDPA_ATTR_DEV_VENDOR_ID, vendor_id)) 605 goto msg_err; 606 if (nla_put_u32(msg, VDPA_ATTR_DEV_MAX_VQS, vdev->nvqs)) 607 goto msg_err; 608 if (nla_put_u16(msg, VDPA_ATTR_DEV_MAX_VQ_SIZE, max_vq_size)) 609 goto msg_err; 610 if (nla_put_u16(msg, VDPA_ATTR_DEV_MIN_VQ_SIZE, min_vq_size)) 611 goto msg_err; 612 613 genlmsg_end(msg, hdr); 614 return 0; 615 616 msg_err: 617 genlmsg_cancel(msg, hdr); 618 return err; 619 } 620 621 static int vdpa_nl_cmd_dev_get_doit(struct sk_buff *skb, struct genl_info *info) 622 { 623 struct vdpa_device *vdev; 624 struct sk_buff *msg; 625 const char *devname; 626 struct device *dev; 627 int err; 628 629 if (!info->attrs[VDPA_ATTR_DEV_NAME]) 630 return -EINVAL; 631 devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]); 632 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 633 if (!msg) 634 return -ENOMEM; 635 636 mutex_lock(&vdpa_dev_mutex); 637 dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match); 638 if (!dev) { 639 NL_SET_ERR_MSG_MOD(info->extack, "device not found"); 640 err = -ENODEV; 641 goto err; 642 } 643 vdev = container_of(dev, struct vdpa_device, dev); 644 if (!vdev->mdev) { 645 err = -EINVAL; 646 goto mdev_err; 647 } 648 err = vdpa_dev_fill(vdev, msg, info->snd_portid, info->snd_seq, 0, info->extack); 649 if (!err) 650 err = genlmsg_reply(msg, info); 651 mdev_err: 652 put_device(dev); 653 err: 654 mutex_unlock(&vdpa_dev_mutex); 655 if (err) 656 nlmsg_free(msg); 657 return err; 658 } 659 660 struct vdpa_dev_dump_info { 661 struct sk_buff *msg; 662 struct netlink_callback *cb; 663 int start_idx; 664 int idx; 665 }; 666 667 static int vdpa_dev_dump(struct device *dev, void *data) 668 { 669 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev); 670 struct vdpa_dev_dump_info *info = data; 671 int err; 672 673 if (!vdev->mdev) 674 return 0; 675 if (info->idx < info->start_idx) { 676 info->idx++; 677 return 0; 678 } 679 err = vdpa_dev_fill(vdev, info->msg, NETLINK_CB(info->cb->skb).portid, 680 info->cb->nlh->nlmsg_seq, NLM_F_MULTI, info->cb->extack); 681 if (err) 682 return err; 683 684 info->idx++; 685 return 0; 686 } 687 688 static int vdpa_nl_cmd_dev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb) 689 { 690 struct vdpa_dev_dump_info info; 691 692 info.msg = msg; 693 info.cb = cb; 694 info.start_idx = cb->args[0]; 695 info.idx = 0; 696 697 mutex_lock(&vdpa_dev_mutex); 698 bus_for_each_dev(&vdpa_bus, NULL, &info, vdpa_dev_dump); 699 mutex_unlock(&vdpa_dev_mutex); 700 cb->args[0] = info.idx; 701 return msg->len; 702 } 703 704 static int vdpa_dev_net_mq_config_fill(struct vdpa_device *vdev, 705 struct sk_buff *msg, u64 features, 706 const struct virtio_net_config *config) 707 { 708 u16 val_u16; 709 710 if ((features & (1ULL << VIRTIO_NET_F_MQ)) == 0) 711 return 0; 712 713 val_u16 = le16_to_cpu(config->max_virtqueue_pairs); 714 return nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MAX_VQP, val_u16); 715 } 716 717 static int vdpa_dev_net_config_fill(struct vdpa_device *vdev, struct sk_buff *msg) 718 { 719 struct virtio_net_config config = {}; 720 u64 features; 721 u16 val_u16; 722 723 vdpa_get_config(vdev, 0, &config, sizeof(config)); 724 725 if (nla_put(msg, VDPA_ATTR_DEV_NET_CFG_MACADDR, sizeof(config.mac), 726 config.mac)) 727 return -EMSGSIZE; 728 729 val_u16 = le16_to_cpu(config.status); 730 if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_STATUS, val_u16)) 731 return -EMSGSIZE; 732 733 val_u16 = le16_to_cpu(config.mtu); 734 if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MTU, val_u16)) 735 return -EMSGSIZE; 736 737 features = vdev->config->get_features(vdev); 738 739 return vdpa_dev_net_mq_config_fill(vdev, msg, features, &config); 740 } 741 742 static int 743 vdpa_dev_config_fill(struct vdpa_device *vdev, struct sk_buff *msg, u32 portid, u32 seq, 744 int flags, struct netlink_ext_ack *extack) 745 { 746 u32 device_id; 747 void *hdr; 748 int err; 749 750 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, 751 VDPA_CMD_DEV_CONFIG_GET); 752 if (!hdr) 753 return -EMSGSIZE; 754 755 if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev))) { 756 err = -EMSGSIZE; 757 goto msg_err; 758 } 759 760 device_id = vdev->config->get_device_id(vdev); 761 if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id)) { 762 err = -EMSGSIZE; 763 goto msg_err; 764 } 765 766 switch (device_id) { 767 case VIRTIO_ID_NET: 768 err = vdpa_dev_net_config_fill(vdev, msg); 769 break; 770 default: 771 err = -EOPNOTSUPP; 772 break; 773 } 774 if (err) 775 goto msg_err; 776 777 genlmsg_end(msg, hdr); 778 return 0; 779 780 msg_err: 781 genlmsg_cancel(msg, hdr); 782 return err; 783 } 784 785 static int vdpa_nl_cmd_dev_config_get_doit(struct sk_buff *skb, struct genl_info *info) 786 { 787 struct vdpa_device *vdev; 788 struct sk_buff *msg; 789 const char *devname; 790 struct device *dev; 791 int err; 792 793 if (!info->attrs[VDPA_ATTR_DEV_NAME]) 794 return -EINVAL; 795 devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]); 796 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 797 if (!msg) 798 return -ENOMEM; 799 800 mutex_lock(&vdpa_dev_mutex); 801 dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match); 802 if (!dev) { 803 NL_SET_ERR_MSG_MOD(info->extack, "device not found"); 804 err = -ENODEV; 805 goto dev_err; 806 } 807 vdev = container_of(dev, struct vdpa_device, dev); 808 if (!vdev->mdev) { 809 NL_SET_ERR_MSG_MOD(info->extack, "unmanaged vdpa device"); 810 err = -EINVAL; 811 goto mdev_err; 812 } 813 err = vdpa_dev_config_fill(vdev, msg, info->snd_portid, info->snd_seq, 814 0, info->extack); 815 if (!err) 816 err = genlmsg_reply(msg, info); 817 818 mdev_err: 819 put_device(dev); 820 dev_err: 821 mutex_unlock(&vdpa_dev_mutex); 822 if (err) 823 nlmsg_free(msg); 824 return err; 825 } 826 827 static int vdpa_dev_config_dump(struct device *dev, void *data) 828 { 829 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev); 830 struct vdpa_dev_dump_info *info = data; 831 int err; 832 833 if (!vdev->mdev) 834 return 0; 835 if (info->idx < info->start_idx) { 836 info->idx++; 837 return 0; 838 } 839 err = vdpa_dev_config_fill(vdev, info->msg, NETLINK_CB(info->cb->skb).portid, 840 info->cb->nlh->nlmsg_seq, NLM_F_MULTI, 841 info->cb->extack); 842 if (err) 843 return err; 844 845 info->idx++; 846 return 0; 847 } 848 849 static int 850 vdpa_nl_cmd_dev_config_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb) 851 { 852 struct vdpa_dev_dump_info info; 853 854 info.msg = msg; 855 info.cb = cb; 856 info.start_idx = cb->args[0]; 857 info.idx = 0; 858 859 mutex_lock(&vdpa_dev_mutex); 860 bus_for_each_dev(&vdpa_bus, NULL, &info, vdpa_dev_config_dump); 861 mutex_unlock(&vdpa_dev_mutex); 862 cb->args[0] = info.idx; 863 return msg->len; 864 } 865 866 static const struct nla_policy vdpa_nl_policy[VDPA_ATTR_MAX + 1] = { 867 [VDPA_ATTR_MGMTDEV_BUS_NAME] = { .type = NLA_NUL_STRING }, 868 [VDPA_ATTR_MGMTDEV_DEV_NAME] = { .type = NLA_STRING }, 869 [VDPA_ATTR_DEV_NAME] = { .type = NLA_STRING }, 870 [VDPA_ATTR_DEV_NET_CFG_MACADDR] = NLA_POLICY_ETH_ADDR, 871 /* virtio spec 1.1 section 5.1.4.1 for valid MTU range */ 872 [VDPA_ATTR_DEV_NET_CFG_MTU] = NLA_POLICY_MIN(NLA_U16, 68), 873 }; 874 875 static const struct genl_ops vdpa_nl_ops[] = { 876 { 877 .cmd = VDPA_CMD_MGMTDEV_GET, 878 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 879 .doit = vdpa_nl_cmd_mgmtdev_get_doit, 880 .dumpit = vdpa_nl_cmd_mgmtdev_get_dumpit, 881 }, 882 { 883 .cmd = VDPA_CMD_DEV_NEW, 884 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 885 .doit = vdpa_nl_cmd_dev_add_set_doit, 886 .flags = GENL_ADMIN_PERM, 887 }, 888 { 889 .cmd = VDPA_CMD_DEV_DEL, 890 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 891 .doit = vdpa_nl_cmd_dev_del_set_doit, 892 .flags = GENL_ADMIN_PERM, 893 }, 894 { 895 .cmd = VDPA_CMD_DEV_GET, 896 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 897 .doit = vdpa_nl_cmd_dev_get_doit, 898 .dumpit = vdpa_nl_cmd_dev_get_dumpit, 899 }, 900 { 901 .cmd = VDPA_CMD_DEV_CONFIG_GET, 902 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 903 .doit = vdpa_nl_cmd_dev_config_get_doit, 904 .dumpit = vdpa_nl_cmd_dev_config_get_dumpit, 905 }, 906 }; 907 908 static struct genl_family vdpa_nl_family __ro_after_init = { 909 .name = VDPA_GENL_NAME, 910 .version = VDPA_GENL_VERSION, 911 .maxattr = VDPA_ATTR_MAX, 912 .policy = vdpa_nl_policy, 913 .netnsok = false, 914 .module = THIS_MODULE, 915 .ops = vdpa_nl_ops, 916 .n_ops = ARRAY_SIZE(vdpa_nl_ops), 917 }; 918 919 static int vdpa_init(void) 920 { 921 int err; 922 923 err = bus_register(&vdpa_bus); 924 if (err) 925 return err; 926 err = genl_register_family(&vdpa_nl_family); 927 if (err) 928 goto err; 929 return 0; 930 931 err: 932 bus_unregister(&vdpa_bus); 933 return err; 934 } 935 936 static void __exit vdpa_exit(void) 937 { 938 genl_unregister_family(&vdpa_nl_family); 939 bus_unregister(&vdpa_bus); 940 ida_destroy(&vdpa_index_ida); 941 } 942 core_initcall(vdpa_init); 943 module_exit(vdpa_exit); 944 945 MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>"); 946 MODULE_LICENSE("GPL v2"); 947