1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (c) 2020, Red Hat. All rights reserved.
6 * Author: Jason Wang <jasowang@redhat.com>
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>
19 static LIST_HEAD(mdev_head);
20 /* A global mutex that protects vdpa management device and device level operations. */
21 static DECLARE_RWSEM(vdpa_dev_lock);
22 static DEFINE_IDA(vdpa_index_ida);
24 void vdpa_set_status(struct vdpa_device *vdev, u8 status)
26 down_write(&vdev->cf_lock);
27 vdev->config->set_status(vdev, status);
28 up_write(&vdev->cf_lock);
30 EXPORT_SYMBOL(vdpa_set_status);
32 static struct genl_family vdpa_nl_family;
34 static int vdpa_dev_probe(struct device *d)
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;
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)
48 if (drv && drv->probe)
49 ret = drv->probe(vdev);
54 static void vdpa_dev_remove(struct device *d)
56 struct vdpa_device *vdev = dev_to_vdpa(d);
57 struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
59 if (drv && drv->remove)
63 static int vdpa_dev_match(struct device *dev, struct device_driver *drv)
65 struct vdpa_device *vdev = dev_to_vdpa(dev);
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;
71 /* Currently devices must be supported by all vDPA bus drivers */
75 static ssize_t driver_override_store(struct device *dev,
76 struct device_attribute *attr,
77 const char *buf, size_t count)
79 struct vdpa_device *vdev = dev_to_vdpa(dev);
80 const char *driver_override, *old;
83 /* We need to keep extra room for a newline */
84 if (count >= (PAGE_SIZE - 1))
87 driver_override = kstrndup(buf, count, GFP_KERNEL);
91 cp = strchr(driver_override, '\n');
96 old = vdev->driver_override;
97 if (strlen(driver_override)) {
98 vdev->driver_override = driver_override;
100 kfree(driver_override);
101 vdev->driver_override = NULL;
110 static ssize_t driver_override_show(struct device *dev,
111 struct device_attribute *attr, char *buf)
113 struct vdpa_device *vdev = dev_to_vdpa(dev);
117 len = snprintf(buf, PAGE_SIZE, "%s\n", vdev->driver_override);
122 static DEVICE_ATTR_RW(driver_override);
124 static struct attribute *vdpa_dev_attrs[] = {
125 &dev_attr_driver_override.attr,
129 static const struct attribute_group vdpa_dev_group = {
130 .attrs = vdpa_dev_attrs,
132 __ATTRIBUTE_GROUPS(vdpa_dev);
134 static struct bus_type vdpa_bus = {
136 .dev_groups = vdpa_dev_groups,
137 .match = vdpa_dev_match,
138 .probe = vdpa_dev_probe,
139 .remove = vdpa_dev_remove,
142 static void vdpa_release_dev(struct device *d)
144 struct vdpa_device *vdev = dev_to_vdpa(d);
145 const struct vdpa_config_ops *ops = vdev->config;
150 ida_simple_remove(&vdpa_index_ida, vdev->index);
151 kfree(vdev->driver_override);
156 * __vdpa_alloc_device - allocate and initilaize a vDPA device
157 * This allows driver to some prepartion after device is
158 * initialized but before registered.
159 * @parent: the parent device
160 * @config: the bus operations that is supported by this device
161 * @ngroups: number of groups supported by this device
162 * @nas: number of address spaces supported by this device
163 * @size: size of the parent structure that contains private data
164 * @name: name of the vdpa device; optional.
165 * @use_va: indicate whether virtual address must be used by this device
167 * Driver should use vdpa_alloc_device() wrapper macro instead of
168 * using this directly.
170 * Return: Returns an error when parent/config/dma_dev is not set or fail to get
173 struct vdpa_device *__vdpa_alloc_device(struct device *parent,
174 const struct vdpa_config_ops *config,
175 unsigned int ngroups, unsigned int nas,
176 size_t size, const char *name,
179 struct vdpa_device *vdev;
185 if (!!config->dma_map != !!config->dma_unmap)
188 /* It should only work for the device that use on-chip IOMMU */
189 if (use_va && !(config->dma_map || config->set_map))
193 vdev = kzalloc(size, GFP_KERNEL);
197 err = ida_alloc(&vdpa_index_ida, GFP_KERNEL);
201 vdev->dev.bus = &vdpa_bus;
202 vdev->dev.parent = parent;
203 vdev->dev.release = vdpa_release_dev;
205 vdev->config = config;
206 vdev->features_valid = false;
207 vdev->use_va = use_va;
208 vdev->ngroups = ngroups;
212 err = dev_set_name(&vdev->dev, "%s", name);
214 err = dev_set_name(&vdev->dev, "vdpa%u", vdev->index);
218 init_rwsem(&vdev->cf_lock);
219 device_initialize(&vdev->dev);
224 ida_simple_remove(&vdpa_index_ida, vdev->index);
230 EXPORT_SYMBOL_GPL(__vdpa_alloc_device);
232 static int vdpa_name_match(struct device *dev, const void *data)
234 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
236 return (strcmp(dev_name(&vdev->dev), data) == 0);
239 static int __vdpa_register_device(struct vdpa_device *vdev, u32 nvqs)
245 lockdep_assert_held(&vdpa_dev_lock);
246 dev = bus_find_device(&vdpa_bus, NULL, dev_name(&vdev->dev), vdpa_name_match);
251 return device_add(&vdev->dev);
255 * _vdpa_register_device - register a vDPA device with vdpa lock held
256 * Caller must have a succeed call of vdpa_alloc_device() before.
257 * Caller must invoke this routine in the management device dev_add()
258 * callback after setting up valid mgmtdev for this vdpa device.
259 * @vdev: the vdpa device to be registered to vDPA bus
260 * @nvqs: number of virtqueues supported by this device
262 * Return: Returns an error when fail to add device to vDPA bus
264 int _vdpa_register_device(struct vdpa_device *vdev, u32 nvqs)
269 return __vdpa_register_device(vdev, nvqs);
271 EXPORT_SYMBOL_GPL(_vdpa_register_device);
274 * vdpa_register_device - register a vDPA device
275 * Callers must have a succeed call of vdpa_alloc_device() before.
276 * @vdev: the vdpa device to be registered to vDPA bus
277 * @nvqs: number of virtqueues supported by this device
279 * Return: Returns an error when fail to add to vDPA bus
281 int vdpa_register_device(struct vdpa_device *vdev, u32 nvqs)
285 down_write(&vdpa_dev_lock);
286 err = __vdpa_register_device(vdev, nvqs);
287 up_write(&vdpa_dev_lock);
290 EXPORT_SYMBOL_GPL(vdpa_register_device);
293 * _vdpa_unregister_device - unregister a vDPA device
294 * Caller must invoke this routine as part of management device dev_del()
296 * @vdev: the vdpa device to be unregisted from vDPA bus
298 void _vdpa_unregister_device(struct vdpa_device *vdev)
300 lockdep_assert_held(&vdpa_dev_lock);
301 WARN_ON(!vdev->mdev);
302 device_unregister(&vdev->dev);
304 EXPORT_SYMBOL_GPL(_vdpa_unregister_device);
307 * vdpa_unregister_device - unregister a vDPA device
308 * @vdev: the vdpa device to be unregisted from vDPA bus
310 void vdpa_unregister_device(struct vdpa_device *vdev)
312 down_write(&vdpa_dev_lock);
313 device_unregister(&vdev->dev);
314 up_write(&vdpa_dev_lock);
316 EXPORT_SYMBOL_GPL(vdpa_unregister_device);
319 * __vdpa_register_driver - register a vDPA device driver
320 * @drv: the vdpa device driver to be registered
321 * @owner: module owner of the driver
323 * Return: Returns an err when fail to do the registration
325 int __vdpa_register_driver(struct vdpa_driver *drv, struct module *owner)
327 drv->driver.bus = &vdpa_bus;
328 drv->driver.owner = owner;
330 return driver_register(&drv->driver);
332 EXPORT_SYMBOL_GPL(__vdpa_register_driver);
335 * vdpa_unregister_driver - unregister a vDPA device driver
336 * @drv: the vdpa device driver to be unregistered
338 void vdpa_unregister_driver(struct vdpa_driver *drv)
340 driver_unregister(&drv->driver);
342 EXPORT_SYMBOL_GPL(vdpa_unregister_driver);
345 * vdpa_mgmtdev_register - register a vdpa management device
347 * @mdev: Pointer to vdpa management device
348 * vdpa_mgmtdev_register() register a vdpa management device which supports
349 * vdpa device management.
350 * Return: Returns 0 on success or failure when required callback ops are not
353 int vdpa_mgmtdev_register(struct vdpa_mgmt_dev *mdev)
355 if (!mdev->device || !mdev->ops || !mdev->ops->dev_add || !mdev->ops->dev_del)
358 INIT_LIST_HEAD(&mdev->list);
359 down_write(&vdpa_dev_lock);
360 list_add_tail(&mdev->list, &mdev_head);
361 up_write(&vdpa_dev_lock);
364 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_register);
366 static int vdpa_match_remove(struct device *dev, void *data)
368 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
369 struct vdpa_mgmt_dev *mdev = vdev->mdev;
372 mdev->ops->dev_del(mdev, vdev);
376 void vdpa_mgmtdev_unregister(struct vdpa_mgmt_dev *mdev)
378 down_write(&vdpa_dev_lock);
380 list_del(&mdev->list);
382 /* Filter out all the entries belong to this management device and delete it. */
383 bus_for_each_dev(&vdpa_bus, NULL, mdev, vdpa_match_remove);
385 up_write(&vdpa_dev_lock);
387 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_unregister);
389 static void vdpa_get_config_unlocked(struct vdpa_device *vdev,
391 void *buf, unsigned int len)
393 const struct vdpa_config_ops *ops = vdev->config;
396 * Config accesses aren't supposed to trigger before features are set.
397 * If it does happen we assume a legacy guest.
399 if (!vdev->features_valid)
400 vdpa_set_features_unlocked(vdev, 0);
401 ops->get_config(vdev, offset, buf, len);
405 * vdpa_get_config - Get one or more device configuration fields.
406 * @vdev: vdpa device to operate on
407 * @offset: starting byte offset of the field
408 * @buf: buffer pointer to read to
409 * @len: length of the configuration fields in bytes
411 void vdpa_get_config(struct vdpa_device *vdev, unsigned int offset,
412 void *buf, unsigned int len)
414 down_read(&vdev->cf_lock);
415 vdpa_get_config_unlocked(vdev, offset, buf, len);
416 up_read(&vdev->cf_lock);
418 EXPORT_SYMBOL_GPL(vdpa_get_config);
421 * vdpa_set_config - Set one or more device configuration fields.
422 * @vdev: vdpa device to operate on
423 * @offset: starting byte offset of the field
424 * @buf: buffer pointer to read from
425 * @length: length of the configuration fields in bytes
427 void vdpa_set_config(struct vdpa_device *vdev, unsigned int offset,
428 const void *buf, unsigned int length)
430 down_write(&vdev->cf_lock);
431 vdev->config->set_config(vdev, offset, buf, length);
432 up_write(&vdev->cf_lock);
434 EXPORT_SYMBOL_GPL(vdpa_set_config);
436 static bool mgmtdev_handle_match(const struct vdpa_mgmt_dev *mdev,
437 const char *busname, const char *devname)
439 /* Bus name is optional for simulated management device, so ignore the
440 * device with bus if bus attribute is provided.
442 if ((busname && !mdev->device->bus) || (!busname && mdev->device->bus))
445 if (!busname && strcmp(dev_name(mdev->device), devname) == 0)
448 if (busname && (strcmp(mdev->device->bus->name, busname) == 0) &&
449 (strcmp(dev_name(mdev->device), devname) == 0))
455 static struct vdpa_mgmt_dev *vdpa_mgmtdev_get_from_attr(struct nlattr **attrs)
457 struct vdpa_mgmt_dev *mdev;
458 const char *busname = NULL;
461 if (!attrs[VDPA_ATTR_MGMTDEV_DEV_NAME])
462 return ERR_PTR(-EINVAL);
463 devname = nla_data(attrs[VDPA_ATTR_MGMTDEV_DEV_NAME]);
464 if (attrs[VDPA_ATTR_MGMTDEV_BUS_NAME])
465 busname = nla_data(attrs[VDPA_ATTR_MGMTDEV_BUS_NAME]);
467 list_for_each_entry(mdev, &mdev_head, list) {
468 if (mgmtdev_handle_match(mdev, busname, devname))
471 return ERR_PTR(-ENODEV);
474 static int vdpa_nl_mgmtdev_handle_fill(struct sk_buff *msg, const struct vdpa_mgmt_dev *mdev)
476 if (mdev->device->bus &&
477 nla_put_string(msg, VDPA_ATTR_MGMTDEV_BUS_NAME, mdev->device->bus->name))
479 if (nla_put_string(msg, VDPA_ATTR_MGMTDEV_DEV_NAME, dev_name(mdev->device)))
484 static int vdpa_mgmtdev_fill(const struct vdpa_mgmt_dev *mdev, struct sk_buff *msg,
485 u32 portid, u32 seq, int flags)
487 u64 supported_classes = 0;
492 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_MGMTDEV_NEW);
495 err = vdpa_nl_mgmtdev_handle_fill(msg, mdev);
499 while (mdev->id_table[i].device) {
500 if (mdev->id_table[i].device <= 63)
501 supported_classes |= BIT_ULL(mdev->id_table[i].device);
505 if (nla_put_u64_64bit(msg, VDPA_ATTR_MGMTDEV_SUPPORTED_CLASSES,
506 supported_classes, VDPA_ATTR_UNSPEC)) {
510 if (nla_put_u32(msg, VDPA_ATTR_DEV_MGMTDEV_MAX_VQS,
511 mdev->max_supported_vqs)) {
515 if (nla_put_u64_64bit(msg, VDPA_ATTR_DEV_SUPPORTED_FEATURES,
516 mdev->supported_features, VDPA_ATTR_PAD)) {
521 genlmsg_end(msg, hdr);
525 genlmsg_cancel(msg, hdr);
529 static int vdpa_nl_cmd_mgmtdev_get_doit(struct sk_buff *skb, struct genl_info *info)
531 struct vdpa_mgmt_dev *mdev;
535 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
539 down_read(&vdpa_dev_lock);
540 mdev = vdpa_mgmtdev_get_from_attr(info->attrs);
542 up_read(&vdpa_dev_lock);
543 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified mgmt device");
548 err = vdpa_mgmtdev_fill(mdev, msg, info->snd_portid, info->snd_seq, 0);
549 up_read(&vdpa_dev_lock);
552 err = genlmsg_reply(msg, info);
561 vdpa_nl_cmd_mgmtdev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
563 struct vdpa_mgmt_dev *mdev;
564 int start = cb->args[0];
568 down_read(&vdpa_dev_lock);
569 list_for_each_entry(mdev, &mdev_head, list) {
574 err = vdpa_mgmtdev_fill(mdev, msg, NETLINK_CB(cb->skb).portid,
575 cb->nlh->nlmsg_seq, NLM_F_MULTI);
581 up_read(&vdpa_dev_lock);
586 #define VDPA_DEV_NET_ATTRS_MASK (BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MACADDR) | \
587 BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MTU) | \
588 BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MAX_VQP))
590 static int vdpa_nl_cmd_dev_add_set_doit(struct sk_buff *skb, struct genl_info *info)
592 struct vdpa_dev_set_config config = {};
593 struct nlattr **nl_attrs = info->attrs;
594 struct vdpa_mgmt_dev *mdev;
599 if (!info->attrs[VDPA_ATTR_DEV_NAME])
602 name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
604 if (nl_attrs[VDPA_ATTR_DEV_NET_CFG_MACADDR]) {
605 macaddr = nla_data(nl_attrs[VDPA_ATTR_DEV_NET_CFG_MACADDR]);
606 memcpy(config.net.mac, macaddr, sizeof(config.net.mac));
607 config.mask |= BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MACADDR);
609 if (nl_attrs[VDPA_ATTR_DEV_NET_CFG_MTU]) {
611 nla_get_u16(nl_attrs[VDPA_ATTR_DEV_NET_CFG_MTU]);
612 config.mask |= BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MTU);
614 if (nl_attrs[VDPA_ATTR_DEV_NET_CFG_MAX_VQP]) {
615 config.net.max_vq_pairs =
616 nla_get_u16(nl_attrs[VDPA_ATTR_DEV_NET_CFG_MAX_VQP]);
617 if (!config.net.max_vq_pairs) {
618 NL_SET_ERR_MSG_MOD(info->extack,
619 "At least one pair of VQs is required");
622 config.mask |= BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MAX_VQP);
625 /* Skip checking capability if user didn't prefer to configure any
626 * device networking attributes. It is likely that user might have used
627 * a device specific method to configure such attributes or using device
628 * default attributes.
630 if ((config.mask & VDPA_DEV_NET_ATTRS_MASK) &&
631 !netlink_capable(skb, CAP_NET_ADMIN))
634 down_write(&vdpa_dev_lock);
635 mdev = vdpa_mgmtdev_get_from_attr(info->attrs);
637 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified management device");
641 if ((config.mask & mdev->config_attr_mask) != config.mask) {
642 NL_SET_ERR_MSG_MOD(info->extack,
643 "All provided attributes are not supported");
648 err = mdev->ops->dev_add(mdev, name, &config);
650 up_write(&vdpa_dev_lock);
654 static int vdpa_nl_cmd_dev_del_set_doit(struct sk_buff *skb, struct genl_info *info)
656 struct vdpa_mgmt_dev *mdev;
657 struct vdpa_device *vdev;
662 if (!info->attrs[VDPA_ATTR_DEV_NAME])
664 name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
666 down_write(&vdpa_dev_lock);
667 dev = bus_find_device(&vdpa_bus, NULL, name, vdpa_name_match);
669 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
673 vdev = container_of(dev, struct vdpa_device, dev);
675 NL_SET_ERR_MSG_MOD(info->extack, "Only user created device can be deleted by user");
680 mdev->ops->dev_del(mdev, vdev);
684 up_write(&vdpa_dev_lock);
689 vdpa_dev_fill(struct vdpa_device *vdev, struct sk_buff *msg, u32 portid, u32 seq,
690 int flags, struct netlink_ext_ack *extack)
699 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_DEV_NEW);
703 err = vdpa_nl_mgmtdev_handle_fill(msg, vdev->mdev);
707 device_id = vdev->config->get_device_id(vdev);
708 vendor_id = vdev->config->get_vendor_id(vdev);
709 max_vq_size = vdev->config->get_vq_num_max(vdev);
710 if (vdev->config->get_vq_num_min)
711 min_vq_size = vdev->config->get_vq_num_min(vdev);
714 if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev)))
716 if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id))
718 if (nla_put_u32(msg, VDPA_ATTR_DEV_VENDOR_ID, vendor_id))
720 if (nla_put_u32(msg, VDPA_ATTR_DEV_MAX_VQS, vdev->nvqs))
722 if (nla_put_u16(msg, VDPA_ATTR_DEV_MAX_VQ_SIZE, max_vq_size))
724 if (nla_put_u16(msg, VDPA_ATTR_DEV_MIN_VQ_SIZE, min_vq_size))
727 genlmsg_end(msg, hdr);
731 genlmsg_cancel(msg, hdr);
735 static int vdpa_nl_cmd_dev_get_doit(struct sk_buff *skb, struct genl_info *info)
737 struct vdpa_device *vdev;
743 if (!info->attrs[VDPA_ATTR_DEV_NAME])
745 devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
746 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
750 down_read(&vdpa_dev_lock);
751 dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match);
753 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
757 vdev = container_of(dev, struct vdpa_device, dev);
762 err = vdpa_dev_fill(vdev, msg, info->snd_portid, info->snd_seq, 0, info->extack);
766 err = genlmsg_reply(msg, info);
768 up_read(&vdpa_dev_lock);
774 up_read(&vdpa_dev_lock);
779 struct vdpa_dev_dump_info {
781 struct netlink_callback *cb;
786 static int vdpa_dev_dump(struct device *dev, void *data)
788 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
789 struct vdpa_dev_dump_info *info = data;
794 if (info->idx < info->start_idx) {
798 err = vdpa_dev_fill(vdev, info->msg, NETLINK_CB(info->cb->skb).portid,
799 info->cb->nlh->nlmsg_seq, NLM_F_MULTI, info->cb->extack);
807 static int vdpa_nl_cmd_dev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
809 struct vdpa_dev_dump_info info;
813 info.start_idx = cb->args[0];
816 down_read(&vdpa_dev_lock);
817 bus_for_each_dev(&vdpa_bus, NULL, &info, vdpa_dev_dump);
818 up_read(&vdpa_dev_lock);
819 cb->args[0] = info.idx;
823 static int vdpa_dev_net_mq_config_fill(struct vdpa_device *vdev,
824 struct sk_buff *msg, u64 features,
825 const struct virtio_net_config *config)
829 if ((features & BIT_ULL(VIRTIO_NET_F_MQ)) == 0)
832 val_u16 = le16_to_cpu(config->max_virtqueue_pairs);
833 return nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MAX_VQP, val_u16);
836 static int vdpa_dev_net_config_fill(struct vdpa_device *vdev, struct sk_buff *msg)
838 struct virtio_net_config config = {};
842 vdpa_get_config_unlocked(vdev, 0, &config, sizeof(config));
844 if (nla_put(msg, VDPA_ATTR_DEV_NET_CFG_MACADDR, sizeof(config.mac),
848 val_u16 = le16_to_cpu(config.status);
849 if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_STATUS, val_u16))
852 val_u16 = le16_to_cpu(config.mtu);
853 if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MTU, val_u16))
856 features = vdev->config->get_driver_features(vdev);
857 if (nla_put_u64_64bit(msg, VDPA_ATTR_DEV_NEGOTIATED_FEATURES, features,
861 return vdpa_dev_net_mq_config_fill(vdev, msg, features, &config);
865 vdpa_dev_config_fill(struct vdpa_device *vdev, struct sk_buff *msg, u32 portid, u32 seq,
866 int flags, struct netlink_ext_ack *extack)
873 down_read(&vdev->cf_lock);
874 status = vdev->config->get_status(vdev);
875 if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
876 NL_SET_ERR_MSG_MOD(extack, "Features negotiation not completed");
881 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags,
882 VDPA_CMD_DEV_CONFIG_GET);
888 if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev))) {
893 device_id = vdev->config->get_device_id(vdev);
894 if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id)) {
901 err = vdpa_dev_net_config_fill(vdev, msg);
910 up_read(&vdev->cf_lock);
911 genlmsg_end(msg, hdr);
915 genlmsg_cancel(msg, hdr);
917 up_read(&vdev->cf_lock);
921 static int vdpa_fill_stats_rec(struct vdpa_device *vdev, struct sk_buff *msg,
922 struct genl_info *info, u32 index)
924 struct virtio_net_config config = {};
930 status = vdev->config->get_status(vdev);
931 if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
932 NL_SET_ERR_MSG_MOD(info->extack, "feature negotiation not complete");
935 vdpa_get_config_unlocked(vdev, 0, &config, sizeof(config));
937 max_vqp = le16_to_cpu(config.max_virtqueue_pairs);
938 if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MAX_VQP, max_vqp))
941 features = vdev->config->get_driver_features(vdev);
942 if (nla_put_u64_64bit(msg, VDPA_ATTR_DEV_NEGOTIATED_FEATURES,
943 features, VDPA_ATTR_PAD))
946 if (nla_put_u32(msg, VDPA_ATTR_DEV_QUEUE_INDEX, index))
949 err = vdev->config->get_vendor_vq_stats(vdev, index, msg, info->extack);
956 static int vendor_stats_fill(struct vdpa_device *vdev, struct sk_buff *msg,
957 struct genl_info *info, u32 index)
961 down_read(&vdev->cf_lock);
962 if (!vdev->config->get_vendor_vq_stats) {
967 err = vdpa_fill_stats_rec(vdev, msg, info, index);
969 up_read(&vdev->cf_lock);
973 static int vdpa_dev_vendor_stats_fill(struct vdpa_device *vdev,
975 struct genl_info *info, u32 index)
980 u32 portid = info->snd_portid;
981 u32 seq = info->snd_seq;
984 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags,
985 VDPA_CMD_DEV_VSTATS_GET);
989 if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev))) {
994 device_id = vdev->config->get_device_id(vdev);
995 if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id)) {
1000 switch (device_id) {
1002 if (index > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX) {
1003 NL_SET_ERR_MSG_MOD(info->extack, "queue index excceeds max value");
1008 err = vendor_stats_fill(vdev, msg, info, index);
1014 genlmsg_end(msg, hdr);
1019 genlmsg_cancel(msg, hdr);
1023 static int vdpa_nl_cmd_dev_config_get_doit(struct sk_buff *skb, struct genl_info *info)
1025 struct vdpa_device *vdev;
1026 struct sk_buff *msg;
1027 const char *devname;
1031 if (!info->attrs[VDPA_ATTR_DEV_NAME])
1033 devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
1034 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1038 down_read(&vdpa_dev_lock);
1039 dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match);
1041 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
1045 vdev = container_of(dev, struct vdpa_device, dev);
1047 NL_SET_ERR_MSG_MOD(info->extack, "unmanaged vdpa device");
1051 err = vdpa_dev_config_fill(vdev, msg, info->snd_portid, info->snd_seq,
1054 err = genlmsg_reply(msg, info);
1059 up_read(&vdpa_dev_lock);
1065 static int vdpa_dev_config_dump(struct device *dev, void *data)
1067 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
1068 struct vdpa_dev_dump_info *info = data;
1073 if (info->idx < info->start_idx) {
1077 err = vdpa_dev_config_fill(vdev, info->msg, NETLINK_CB(info->cb->skb).portid,
1078 info->cb->nlh->nlmsg_seq, NLM_F_MULTI,
1088 vdpa_nl_cmd_dev_config_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
1090 struct vdpa_dev_dump_info info;
1094 info.start_idx = cb->args[0];
1097 down_read(&vdpa_dev_lock);
1098 bus_for_each_dev(&vdpa_bus, NULL, &info, vdpa_dev_config_dump);
1099 up_read(&vdpa_dev_lock);
1100 cb->args[0] = info.idx;
1104 static int vdpa_nl_cmd_dev_stats_get_doit(struct sk_buff *skb,
1105 struct genl_info *info)
1107 struct vdpa_device *vdev;
1108 struct sk_buff *msg;
1109 const char *devname;
1114 if (!info->attrs[VDPA_ATTR_DEV_NAME])
1117 if (!info->attrs[VDPA_ATTR_DEV_QUEUE_INDEX])
1120 devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
1121 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1125 index = nla_get_u32(info->attrs[VDPA_ATTR_DEV_QUEUE_INDEX]);
1126 down_read(&vdpa_dev_lock);
1127 dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match);
1129 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
1133 vdev = container_of(dev, struct vdpa_device, dev);
1135 NL_SET_ERR_MSG_MOD(info->extack, "unmanaged vdpa device");
1139 err = vdpa_dev_vendor_stats_fill(vdev, msg, info, index);
1143 err = genlmsg_reply(msg, info);
1146 up_read(&vdpa_dev_lock);
1154 up_read(&vdpa_dev_lock);
1158 static const struct nla_policy vdpa_nl_policy[VDPA_ATTR_MAX + 1] = {
1159 [VDPA_ATTR_MGMTDEV_BUS_NAME] = { .type = NLA_NUL_STRING },
1160 [VDPA_ATTR_MGMTDEV_DEV_NAME] = { .type = NLA_STRING },
1161 [VDPA_ATTR_DEV_NAME] = { .type = NLA_STRING },
1162 [VDPA_ATTR_DEV_NET_CFG_MACADDR] = NLA_POLICY_ETH_ADDR,
1163 /* virtio spec 1.1 section 5.1.4.1 for valid MTU range */
1164 [VDPA_ATTR_DEV_NET_CFG_MTU] = NLA_POLICY_MIN(NLA_U16, 68),
1167 static const struct genl_ops vdpa_nl_ops[] = {
1169 .cmd = VDPA_CMD_MGMTDEV_GET,
1170 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1171 .doit = vdpa_nl_cmd_mgmtdev_get_doit,
1172 .dumpit = vdpa_nl_cmd_mgmtdev_get_dumpit,
1175 .cmd = VDPA_CMD_DEV_NEW,
1176 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1177 .doit = vdpa_nl_cmd_dev_add_set_doit,
1178 .flags = GENL_ADMIN_PERM,
1181 .cmd = VDPA_CMD_DEV_DEL,
1182 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1183 .doit = vdpa_nl_cmd_dev_del_set_doit,
1184 .flags = GENL_ADMIN_PERM,
1187 .cmd = VDPA_CMD_DEV_GET,
1188 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1189 .doit = vdpa_nl_cmd_dev_get_doit,
1190 .dumpit = vdpa_nl_cmd_dev_get_dumpit,
1193 .cmd = VDPA_CMD_DEV_CONFIG_GET,
1194 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1195 .doit = vdpa_nl_cmd_dev_config_get_doit,
1196 .dumpit = vdpa_nl_cmd_dev_config_get_dumpit,
1199 .cmd = VDPA_CMD_DEV_VSTATS_GET,
1200 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1201 .doit = vdpa_nl_cmd_dev_stats_get_doit,
1202 .flags = GENL_ADMIN_PERM,
1206 static struct genl_family vdpa_nl_family __ro_after_init = {
1207 .name = VDPA_GENL_NAME,
1208 .version = VDPA_GENL_VERSION,
1209 .maxattr = VDPA_ATTR_MAX,
1210 .policy = vdpa_nl_policy,
1212 .module = THIS_MODULE,
1214 .n_ops = ARRAY_SIZE(vdpa_nl_ops),
1217 static int vdpa_init(void)
1221 err = bus_register(&vdpa_bus);
1224 err = genl_register_family(&vdpa_nl_family);
1230 bus_unregister(&vdpa_bus);
1234 static void __exit vdpa_exit(void)
1236 genl_unregister_family(&vdpa_nl_family);
1237 bus_unregister(&vdpa_bus);
1238 ida_destroy(&vdpa_index_ida);
1240 core_initcall(vdpa_init);
1241 module_exit(vdpa_exit);
1243 MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>");
1244 MODULE_LICENSE("GPL v2");