drivers/vdpa/vdpa.c

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