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>
18 static LIST_HEAD(mdev_head);
19 /* A global mutex that protects vdpa management device and device level operations. */
20 static DEFINE_MUTEX(vdpa_dev_mutex);
21 static DEFINE_IDA(vdpa_index_ida);
23 static struct genl_family vdpa_nl_family;
25 static int vdpa_dev_probe(struct device *d)
27 struct vdpa_device *vdev = dev_to_vdpa(d);
28 struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
31 if (drv && drv->probe)
32 ret = drv->probe(vdev);
37 static int vdpa_dev_remove(struct device *d)
39 struct vdpa_device *vdev = dev_to_vdpa(d);
40 struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
42 if (drv && drv->remove)
48 static struct bus_type vdpa_bus = {
50 .probe = vdpa_dev_probe,
51 .remove = vdpa_dev_remove,
54 static void vdpa_release_dev(struct device *d)
56 struct vdpa_device *vdev = dev_to_vdpa(d);
57 const struct vdpa_config_ops *ops = vdev->config;
62 ida_simple_remove(&vdpa_index_ida, vdev->index);
67 * __vdpa_alloc_device - allocate and initilaize a vDPA device
68 * This allows driver to some prepartion after device is
69 * initialized but before registered.
70 * @parent: the parent device
71 * @config: the bus operations that is supported by this device
72 * @nvqs: number of virtqueues supported by this device
73 * @size: size of the parent structure that contains private data
74 * @name: name of the vdpa device; optional.
76 * Driver should use vdpa_alloc_device() wrapper macro instead of
77 * using this directly.
79 * Returns an error when parent/config/dma_dev is not set or fail to get
82 struct vdpa_device *__vdpa_alloc_device(struct device *parent,
83 const struct vdpa_config_ops *config,
84 int nvqs, size_t size, const char *name)
86 struct vdpa_device *vdev;
92 if (!!config->dma_map != !!config->dma_unmap)
96 vdev = kzalloc(size, GFP_KERNEL);
100 err = ida_alloc(&vdpa_index_ida, GFP_KERNEL);
104 vdev->dev.bus = &vdpa_bus;
105 vdev->dev.parent = parent;
106 vdev->dev.release = vdpa_release_dev;
108 vdev->config = config;
109 vdev->features_valid = false;
113 err = dev_set_name(&vdev->dev, "%s", name);
115 err = dev_set_name(&vdev->dev, "vdpa%u", vdev->index);
119 device_initialize(&vdev->dev);
124 ida_simple_remove(&vdpa_index_ida, vdev->index);
130 EXPORT_SYMBOL_GPL(__vdpa_alloc_device);
132 static int vdpa_name_match(struct device *dev, const void *data)
134 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
136 return (strcmp(dev_name(&vdev->dev), data) == 0);
139 static int __vdpa_register_device(struct vdpa_device *vdev)
143 lockdep_assert_held(&vdpa_dev_mutex);
144 dev = bus_find_device(&vdpa_bus, NULL, dev_name(&vdev->dev), vdpa_name_match);
149 return device_add(&vdev->dev);
153 * _vdpa_register_device - register a vDPA device with vdpa lock held
154 * Caller must have a succeed call of vdpa_alloc_device() before.
155 * Caller must invoke this routine in the management device dev_add()
156 * callback after setting up valid mgmtdev for this vdpa device.
157 * @vdev: the vdpa device to be registered to vDPA bus
159 * Returns an error when fail to add device to vDPA bus
161 int _vdpa_register_device(struct vdpa_device *vdev)
166 return __vdpa_register_device(vdev);
168 EXPORT_SYMBOL_GPL(_vdpa_register_device);
171 * vdpa_register_device - register a vDPA device
172 * Callers must have a succeed call of vdpa_alloc_device() before.
173 * @vdev: the vdpa device to be registered to vDPA bus
175 * Returns an error when fail to add to vDPA bus
177 int vdpa_register_device(struct vdpa_device *vdev)
181 mutex_lock(&vdpa_dev_mutex);
182 err = __vdpa_register_device(vdev);
183 mutex_unlock(&vdpa_dev_mutex);
186 EXPORT_SYMBOL_GPL(vdpa_register_device);
189 * _vdpa_unregister_device - unregister a vDPA device
190 * Caller must invoke this routine as part of management device dev_del()
192 * @vdev: the vdpa device to be unregisted from vDPA bus
194 void _vdpa_unregister_device(struct vdpa_device *vdev)
196 lockdep_assert_held(&vdpa_dev_mutex);
197 WARN_ON(!vdev->mdev);
198 device_unregister(&vdev->dev);
200 EXPORT_SYMBOL_GPL(_vdpa_unregister_device);
203 * vdpa_unregister_device - unregister a vDPA device
204 * @vdev: the vdpa device to be unregisted from vDPA bus
206 void vdpa_unregister_device(struct vdpa_device *vdev)
208 mutex_lock(&vdpa_dev_mutex);
209 device_unregister(&vdev->dev);
210 mutex_unlock(&vdpa_dev_mutex);
212 EXPORT_SYMBOL_GPL(vdpa_unregister_device);
215 * __vdpa_register_driver - register a vDPA device driver
216 * @drv: the vdpa device driver to be registered
217 * @owner: module owner of the driver
219 * Returns an err when fail to do the registration
221 int __vdpa_register_driver(struct vdpa_driver *drv, struct module *owner)
223 drv->driver.bus = &vdpa_bus;
224 drv->driver.owner = owner;
226 return driver_register(&drv->driver);
228 EXPORT_SYMBOL_GPL(__vdpa_register_driver);
231 * vdpa_unregister_driver - unregister a vDPA device driver
232 * @drv: the vdpa device driver to be unregistered
234 void vdpa_unregister_driver(struct vdpa_driver *drv)
236 driver_unregister(&drv->driver);
238 EXPORT_SYMBOL_GPL(vdpa_unregister_driver);
241 * vdpa_mgmtdev_register - register a vdpa management device
243 * @mdev: Pointer to vdpa management device
244 * vdpa_mgmtdev_register() register a vdpa management device which supports
245 * vdpa device management.
247 int vdpa_mgmtdev_register(struct vdpa_mgmt_dev *mdev)
249 if (!mdev->device || !mdev->ops || !mdev->ops->dev_add || !mdev->ops->dev_del)
252 INIT_LIST_HEAD(&mdev->list);
253 mutex_lock(&vdpa_dev_mutex);
254 list_add_tail(&mdev->list, &mdev_head);
255 mutex_unlock(&vdpa_dev_mutex);
258 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_register);
260 static int vdpa_match_remove(struct device *dev, void *data)
262 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
263 struct vdpa_mgmt_dev *mdev = vdev->mdev;
266 mdev->ops->dev_del(mdev, vdev);
270 void vdpa_mgmtdev_unregister(struct vdpa_mgmt_dev *mdev)
272 mutex_lock(&vdpa_dev_mutex);
274 list_del(&mdev->list);
276 /* Filter out all the entries belong to this management device and delete it. */
277 bus_for_each_dev(&vdpa_bus, NULL, mdev, vdpa_match_remove);
279 mutex_unlock(&vdpa_dev_mutex);
281 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_unregister);
283 static bool mgmtdev_handle_match(const struct vdpa_mgmt_dev *mdev,
284 const char *busname, const char *devname)
286 /* Bus name is optional for simulated management device, so ignore the
287 * device with bus if bus attribute is provided.
289 if ((busname && !mdev->device->bus) || (!busname && mdev->device->bus))
292 if (!busname && strcmp(dev_name(mdev->device), devname) == 0)
295 if (busname && (strcmp(mdev->device->bus->name, busname) == 0) &&
296 (strcmp(dev_name(mdev->device), devname) == 0))
302 static struct vdpa_mgmt_dev *vdpa_mgmtdev_get_from_attr(struct nlattr **attrs)
304 struct vdpa_mgmt_dev *mdev;
305 const char *busname = NULL;
308 if (!attrs[VDPA_ATTR_MGMTDEV_DEV_NAME])
309 return ERR_PTR(-EINVAL);
310 devname = nla_data(attrs[VDPA_ATTR_MGMTDEV_DEV_NAME]);
311 if (attrs[VDPA_ATTR_MGMTDEV_BUS_NAME])
312 busname = nla_data(attrs[VDPA_ATTR_MGMTDEV_BUS_NAME]);
314 list_for_each_entry(mdev, &mdev_head, list) {
315 if (mgmtdev_handle_match(mdev, busname, devname))
318 return ERR_PTR(-ENODEV);
321 static int vdpa_nl_mgmtdev_handle_fill(struct sk_buff *msg, const struct vdpa_mgmt_dev *mdev)
323 if (mdev->device->bus &&
324 nla_put_string(msg, VDPA_ATTR_MGMTDEV_BUS_NAME, mdev->device->bus->name))
326 if (nla_put_string(msg, VDPA_ATTR_MGMTDEV_DEV_NAME, dev_name(mdev->device)))
331 static int vdpa_mgmtdev_fill(const struct vdpa_mgmt_dev *mdev, struct sk_buff *msg,
332 u32 portid, u32 seq, int flags)
334 u64 supported_classes = 0;
339 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_MGMTDEV_NEW);
342 err = vdpa_nl_mgmtdev_handle_fill(msg, mdev);
346 while (mdev->id_table[i].device) {
347 supported_classes |= BIT(mdev->id_table[i].device);
351 if (nla_put_u64_64bit(msg, VDPA_ATTR_MGMTDEV_SUPPORTED_CLASSES,
352 supported_classes, VDPA_ATTR_UNSPEC)) {
357 genlmsg_end(msg, hdr);
361 genlmsg_cancel(msg, hdr);
365 static int vdpa_nl_cmd_mgmtdev_get_doit(struct sk_buff *skb, struct genl_info *info)
367 struct vdpa_mgmt_dev *mdev;
371 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
375 mutex_lock(&vdpa_dev_mutex);
376 mdev = vdpa_mgmtdev_get_from_attr(info->attrs);
378 mutex_unlock(&vdpa_dev_mutex);
379 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified mgmt device");
384 err = vdpa_mgmtdev_fill(mdev, msg, info->snd_portid, info->snd_seq, 0);
385 mutex_unlock(&vdpa_dev_mutex);
388 err = genlmsg_reply(msg, info);
397 vdpa_nl_cmd_mgmtdev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
399 struct vdpa_mgmt_dev *mdev;
400 int start = cb->args[0];
404 mutex_lock(&vdpa_dev_mutex);
405 list_for_each_entry(mdev, &mdev_head, list) {
410 err = vdpa_mgmtdev_fill(mdev, msg, NETLINK_CB(cb->skb).portid,
411 cb->nlh->nlmsg_seq, NLM_F_MULTI);
417 mutex_unlock(&vdpa_dev_mutex);
422 static int vdpa_nl_cmd_dev_add_set_doit(struct sk_buff *skb, struct genl_info *info)
424 struct vdpa_mgmt_dev *mdev;
428 if (!info->attrs[VDPA_ATTR_DEV_NAME])
431 name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
433 mutex_lock(&vdpa_dev_mutex);
434 mdev = vdpa_mgmtdev_get_from_attr(info->attrs);
436 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified management device");
441 err = mdev->ops->dev_add(mdev, name);
443 mutex_unlock(&vdpa_dev_mutex);
447 static int vdpa_nl_cmd_dev_del_set_doit(struct sk_buff *skb, struct genl_info *info)
449 struct vdpa_mgmt_dev *mdev;
450 struct vdpa_device *vdev;
455 if (!info->attrs[VDPA_ATTR_DEV_NAME])
457 name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
459 mutex_lock(&vdpa_dev_mutex);
460 dev = bus_find_device(&vdpa_bus, NULL, name, vdpa_name_match);
462 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
466 vdev = container_of(dev, struct vdpa_device, dev);
468 NL_SET_ERR_MSG_MOD(info->extack, "Only user created device can be deleted by user");
473 mdev->ops->dev_del(mdev, vdev);
477 mutex_unlock(&vdpa_dev_mutex);
482 vdpa_dev_fill(struct vdpa_device *vdev, struct sk_buff *msg, u32 portid, u32 seq,
483 int flags, struct netlink_ext_ack *extack)
491 hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_DEV_NEW);
495 err = vdpa_nl_mgmtdev_handle_fill(msg, vdev->mdev);
499 device_id = vdev->config->get_device_id(vdev);
500 vendor_id = vdev->config->get_vendor_id(vdev);
501 max_vq_size = vdev->config->get_vq_num_max(vdev);
504 if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev)))
506 if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id))
508 if (nla_put_u32(msg, VDPA_ATTR_DEV_VENDOR_ID, vendor_id))
510 if (nla_put_u32(msg, VDPA_ATTR_DEV_MAX_VQS, vdev->nvqs))
512 if (nla_put_u16(msg, VDPA_ATTR_DEV_MAX_VQ_SIZE, max_vq_size))
515 genlmsg_end(msg, hdr);
519 genlmsg_cancel(msg, hdr);
523 static int vdpa_nl_cmd_dev_get_doit(struct sk_buff *skb, struct genl_info *info)
525 struct vdpa_device *vdev;
531 if (!info->attrs[VDPA_ATTR_DEV_NAME])
533 devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
534 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
538 mutex_lock(&vdpa_dev_mutex);
539 dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match);
541 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
545 vdev = container_of(dev, struct vdpa_device, dev);
550 err = vdpa_dev_fill(vdev, msg, info->snd_portid, info->snd_seq, 0, info->extack);
552 err = genlmsg_reply(msg, info);
556 mutex_unlock(&vdpa_dev_mutex);
562 struct vdpa_dev_dump_info {
564 struct netlink_callback *cb;
569 static int vdpa_dev_dump(struct device *dev, void *data)
571 struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
572 struct vdpa_dev_dump_info *info = data;
577 if (info->idx < info->start_idx) {
581 err = vdpa_dev_fill(vdev, info->msg, NETLINK_CB(info->cb->skb).portid,
582 info->cb->nlh->nlmsg_seq, NLM_F_MULTI, info->cb->extack);
590 static int vdpa_nl_cmd_dev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
592 struct vdpa_dev_dump_info info;
596 info.start_idx = cb->args[0];
599 mutex_lock(&vdpa_dev_mutex);
600 bus_for_each_dev(&vdpa_bus, NULL, &info, vdpa_dev_dump);
601 mutex_unlock(&vdpa_dev_mutex);
602 cb->args[0] = info.idx;
606 static const struct nla_policy vdpa_nl_policy[VDPA_ATTR_MAX + 1] = {
607 [VDPA_ATTR_MGMTDEV_BUS_NAME] = { .type = NLA_NUL_STRING },
608 [VDPA_ATTR_MGMTDEV_DEV_NAME] = { .type = NLA_STRING },
609 [VDPA_ATTR_DEV_NAME] = { .type = NLA_STRING },
612 static const struct genl_ops vdpa_nl_ops[] = {
614 .cmd = VDPA_CMD_MGMTDEV_GET,
615 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
616 .doit = vdpa_nl_cmd_mgmtdev_get_doit,
617 .dumpit = vdpa_nl_cmd_mgmtdev_get_dumpit,
620 .cmd = VDPA_CMD_DEV_NEW,
621 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
622 .doit = vdpa_nl_cmd_dev_add_set_doit,
623 .flags = GENL_ADMIN_PERM,
626 .cmd = VDPA_CMD_DEV_DEL,
627 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
628 .doit = vdpa_nl_cmd_dev_del_set_doit,
629 .flags = GENL_ADMIN_PERM,
632 .cmd = VDPA_CMD_DEV_GET,
633 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
634 .doit = vdpa_nl_cmd_dev_get_doit,
635 .dumpit = vdpa_nl_cmd_dev_get_dumpit,
639 static struct genl_family vdpa_nl_family __ro_after_init = {
640 .name = VDPA_GENL_NAME,
641 .version = VDPA_GENL_VERSION,
642 .maxattr = VDPA_ATTR_MAX,
643 .policy = vdpa_nl_policy,
645 .module = THIS_MODULE,
647 .n_ops = ARRAY_SIZE(vdpa_nl_ops),
650 static int vdpa_init(void)
654 err = bus_register(&vdpa_bus);
657 err = genl_register_family(&vdpa_nl_family);
663 bus_unregister(&vdpa_bus);
667 static void __exit vdpa_exit(void)
669 genl_unregister_family(&vdpa_nl_family);
670 bus_unregister(&vdpa_bus);
671 ida_destroy(&vdpa_index_ida);
673 core_initcall(vdpa_init);
674 module_exit(vdpa_exit);
676 MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>");
677 MODULE_LICENSE("GPL v2");