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 DECLARE_RWSEM(vdpa_dev_lock);
  22 static DEFINE_IDA(vdpa_index_ida);
  23
  24 void vdpa_set_status(struct vdpa_device *vdev, u8 status)
  25 {
  26         down_write(&vdev->cf_lock);
  27         vdev->config->set_status(vdev, status);
  28         up_write(&vdev->cf_lock);
  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         kfree(vdev->driver_override);
 152         kfree(vdev);
 153 }
 154
 155 /**
 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
 166  *
 167  * Driver should use vdpa_alloc_device() wrapper macro instead of
 168  * using this directly.
 169  *
 170  * Return: Returns an error when parent/config/dma_dev is not set or fail to get
 171  *         ida.
 172  */
 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,
 177                                         bool use_va)
 178 {
 179         struct vdpa_device *vdev;
 180         int err = -EINVAL;
 181
 182         if (!config)
 183                 goto err;
 184
 185         if (!!config->dma_map != !!config->dma_unmap)
 186                 goto err;
 187
 188         /* It should only work for the device that use on-chip IOMMU */
 189         if (use_va && !(config->dma_map || config->set_map))
 190                 goto err;
 191
 192         err = -ENOMEM;
 193         vdev = kzalloc(size, GFP_KERNEL);
 194         if (!vdev)
 195                 goto err;
 196
 197         err = ida_alloc(&vdpa_index_ida, GFP_KERNEL);
 198         if (err < 0)
 199                 goto err_ida;
 200
 201         vdev->dev.bus = &vdpa_bus;
 202         vdev->dev.parent = parent;
 203         vdev->dev.release = vdpa_release_dev;
 204         vdev->index = err;
 205         vdev->config = config;
 206         vdev->features_valid = false;
 207         vdev->use_va = use_va;
 208         vdev->ngroups = ngroups;
 209         vdev->nas = nas;
 210
 211         if (name)
 212                 err = dev_set_name(&vdev->dev, "%s", name);
 213         else
 214                 err = dev_set_name(&vdev->dev, "vdpa%u", vdev->index);
 215         if (err)
 216                 goto err_name;
 217
 218         init_rwsem(&vdev->cf_lock);
 219         device_initialize(&vdev->dev);
 220
 221         return vdev;
 222
 223 err_name:
 224         ida_simple_remove(&vdpa_index_ida, vdev->index);
 225 err_ida:
 226         kfree(vdev);
 227 err:
 228         return ERR_PTR(err);
 229 }
 230 EXPORT_SYMBOL_GPL(__vdpa_alloc_device);
 231
 232 static int vdpa_name_match(struct device *dev, const void *data)
 233 {
 234         struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
 235
 236         return (strcmp(dev_name(&vdev->dev), data) == 0);
 237 }
 238
 239 static int __vdpa_register_device(struct vdpa_device *vdev, u32 nvqs)
 240 {
 241         struct device *dev;
 242
 243         vdev->nvqs = nvqs;
 244
 245         lockdep_assert_held(&vdpa_dev_lock);
 246         dev = bus_find_device(&vdpa_bus, NULL, dev_name(&vdev->dev), vdpa_name_match);
 247         if (dev) {
 248                 put_device(dev);
 249                 return -EEXIST;
 250         }
 251         return device_add(&vdev->dev);
 252 }
 253
 254 /**
 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
 261  *
 262  * Return: Returns an error when fail to add device to vDPA bus
 263  */
 264 int _vdpa_register_device(struct vdpa_device *vdev, u32 nvqs)
 265 {
 266         if (!vdev->mdev)
 267                 return -EINVAL;
 268
 269         return __vdpa_register_device(vdev, nvqs);
 270 }
 271 EXPORT_SYMBOL_GPL(_vdpa_register_device);
 272
 273 /**
 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
 278  *
 279  * Return: Returns an error when fail to add to vDPA bus
 280  */
 281 int vdpa_register_device(struct vdpa_device *vdev, u32 nvqs)
 282 {
 283         int err;
 284
 285         down_write(&vdpa_dev_lock);
 286         err = __vdpa_register_device(vdev, nvqs);
 287         up_write(&vdpa_dev_lock);
 288         return err;
 289 }
 290 EXPORT_SYMBOL_GPL(vdpa_register_device);
 291
 292 /**
 293  * _vdpa_unregister_device - unregister a vDPA device
 294  * Caller must invoke this routine as part of management device dev_del()
 295  * callback.
 296  * @vdev: the vdpa device to be unregisted from vDPA bus
 297  */
 298 void _vdpa_unregister_device(struct vdpa_device *vdev)
 299 {
 300         lockdep_assert_held(&vdpa_dev_lock);
 301         WARN_ON(!vdev->mdev);
 302         device_unregister(&vdev->dev);
 303 }
 304 EXPORT_SYMBOL_GPL(_vdpa_unregister_device);
 305
 306 /**
 307  * vdpa_unregister_device - unregister a vDPA device
 308  * @vdev: the vdpa device to be unregisted from vDPA bus
 309  */
 310 void vdpa_unregister_device(struct vdpa_device *vdev)
 311 {
 312         down_write(&vdpa_dev_lock);
 313         device_unregister(&vdev->dev);
 314         up_write(&vdpa_dev_lock);
 315 }
 316 EXPORT_SYMBOL_GPL(vdpa_unregister_device);
 317
 318 /**
 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
 322  *
 323  * Return: Returns an err when fail to do the registration
 324  */
 325 int __vdpa_register_driver(struct vdpa_driver *drv, struct module *owner)
 326 {
 327         drv->driver.bus = &vdpa_bus;
 328         drv->driver.owner = owner;
 329
 330         return driver_register(&drv->driver);
 331 }
 332 EXPORT_SYMBOL_GPL(__vdpa_register_driver);
 333
 334 /**
 335  * vdpa_unregister_driver - unregister a vDPA device driver
 336  * @drv: the vdpa device driver to be unregistered
 337  */
 338 void vdpa_unregister_driver(struct vdpa_driver *drv)
 339 {
 340         driver_unregister(&drv->driver);
 341 }
 342 EXPORT_SYMBOL_GPL(vdpa_unregister_driver);
 343
 344 /**
 345  * vdpa_mgmtdev_register - register a vdpa management device
 346  *
 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
 351  *         initialized.
 352  */
 353 int vdpa_mgmtdev_register(struct vdpa_mgmt_dev *mdev)
 354 {
 355         if (!mdev->device || !mdev->ops || !mdev->ops->dev_add || !mdev->ops->dev_del)
 356                 return -EINVAL;
 357
 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);
 362         return 0;
 363 }
 364 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_register);
 365
 366 static int vdpa_match_remove(struct device *dev, void *data)
 367 {
 368         struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
 369         struct vdpa_mgmt_dev *mdev = vdev->mdev;
 370
 371         if (mdev == data)
 372                 mdev->ops->dev_del(mdev, vdev);
 373         return 0;
 374 }
 375
 376 void vdpa_mgmtdev_unregister(struct vdpa_mgmt_dev *mdev)
 377 {
 378         down_write(&vdpa_dev_lock);
 379
 380         list_del(&mdev->list);
 381
 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);
 384
 385         up_write(&vdpa_dev_lock);
 386 }
 387 EXPORT_SYMBOL_GPL(vdpa_mgmtdev_unregister);
 388
 389 static void vdpa_get_config_unlocked(struct vdpa_device *vdev,
 390                                      unsigned int offset,
 391                                      void *buf, unsigned int len)
 392 {
 393         const struct vdpa_config_ops *ops = vdev->config;
 394
 395         /*
 396          * Config accesses aren't supposed to trigger before features are set.
 397          * If it does happen we assume a legacy guest.
 398          */
 399         if (!vdev->features_valid)
 400                 vdpa_set_features_unlocked(vdev, 0);
 401         ops->get_config(vdev, offset, buf, len);
 402 }
 403
 404 /**
 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
 410  */
 411 void vdpa_get_config(struct vdpa_device *vdev, unsigned int offset,
 412                      void *buf, unsigned int len)
 413 {
 414         down_read(&vdev->cf_lock);
 415         vdpa_get_config_unlocked(vdev, offset, buf, len);
 416         up_read(&vdev->cf_lock);
 417 }
 418 EXPORT_SYMBOL_GPL(vdpa_get_config);
 419
 420 /**
 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
 426  */
 427 void vdpa_set_config(struct vdpa_device *vdev, unsigned int offset,
 428                      const void *buf, unsigned int length)
 429 {
 430         down_write(&vdev->cf_lock);
 431         vdev->config->set_config(vdev, offset, buf, length);
 432         up_write(&vdev->cf_lock);
 433 }
 434 EXPORT_SYMBOL_GPL(vdpa_set_config);
 435
 436 static bool mgmtdev_handle_match(const struct vdpa_mgmt_dev *mdev,
 437                                  const char *busname, const char *devname)
 438 {
 439         /* Bus name is optional for simulated management device, so ignore the
 440          * device with bus if bus attribute is provided.
 441          */
 442         if ((busname && !mdev->device->bus) || (!busname && mdev->device->bus))
 443                 return false;
 444
 445         if (!busname && strcmp(dev_name(mdev->device), devname) == 0)
 446                 return true;
 447
 448         if (busname && (strcmp(mdev->device->bus->name, busname) == 0) &&
 449             (strcmp(dev_name(mdev->device), devname) == 0))
 450                 return true;
 451
 452         return false;
 453 }
 454
 455 static struct vdpa_mgmt_dev *vdpa_mgmtdev_get_from_attr(struct nlattr **attrs)
 456 {
 457         struct vdpa_mgmt_dev *mdev;
 458         const char *busname = NULL;
 459         const char *devname;
 460
 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]);
 466
 467         list_for_each_entry(mdev, &mdev_head, list) {
 468                 if (mgmtdev_handle_match(mdev, busname, devname))
 469                         return mdev;
 470         }
 471         return ERR_PTR(-ENODEV);
 472 }
 473
 474 static int vdpa_nl_mgmtdev_handle_fill(struct sk_buff *msg, const struct vdpa_mgmt_dev *mdev)
 475 {
 476         if (mdev->device->bus &&
 477             nla_put_string(msg, VDPA_ATTR_MGMTDEV_BUS_NAME, mdev->device->bus->name))
 478                 return -EMSGSIZE;
 479         if (nla_put_string(msg, VDPA_ATTR_MGMTDEV_DEV_NAME, dev_name(mdev->device)))
 480                 return -EMSGSIZE;
 481         return 0;
 482 }
 483
 484 static int vdpa_mgmtdev_fill(const struct vdpa_mgmt_dev *mdev, struct sk_buff *msg,
 485                              u32 portid, u32 seq, int flags)
 486 {
 487         u64 supported_classes = 0;
 488         void *hdr;
 489         int i = 0;
 490         int err;
 491
 492         hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_MGMTDEV_NEW);
 493         if (!hdr)
 494                 return -EMSGSIZE;
 495         err = vdpa_nl_mgmtdev_handle_fill(msg, mdev);
 496         if (err)
 497                 goto msg_err;
 498
 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);
 502                 i++;
 503         }
 504
 505         if (nla_put_u64_64bit(msg, VDPA_ATTR_MGMTDEV_SUPPORTED_CLASSES,
 506                               supported_classes, VDPA_ATTR_UNSPEC)) {
 507                 err = -EMSGSIZE;
 508                 goto msg_err;
 509         }
 510         if (nla_put_u32(msg, VDPA_ATTR_DEV_MGMTDEV_MAX_VQS,
 511                         mdev->max_supported_vqs)) {
 512                 err = -EMSGSIZE;
 513                 goto msg_err;
 514         }
 515         if (nla_put_u64_64bit(msg, VDPA_ATTR_DEV_SUPPORTED_FEATURES,
 516                               mdev->supported_features, VDPA_ATTR_PAD)) {
 517                 err = -EMSGSIZE;
 518                 goto msg_err;
 519         }
 520
 521         genlmsg_end(msg, hdr);
 522         return 0;
 523
 524 msg_err:
 525         genlmsg_cancel(msg, hdr);
 526         return err;
 527 }
 528
 529 static int vdpa_nl_cmd_mgmtdev_get_doit(struct sk_buff *skb, struct genl_info *info)
 530 {
 531         struct vdpa_mgmt_dev *mdev;
 532         struct sk_buff *msg;
 533         int err;
 534
 535         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 536         if (!msg)
 537                 return -ENOMEM;
 538
 539         down_read(&vdpa_dev_lock);
 540         mdev = vdpa_mgmtdev_get_from_attr(info->attrs);
 541         if (IS_ERR(mdev)) {
 542                 up_read(&vdpa_dev_lock);
 543                 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified mgmt device");
 544                 err = PTR_ERR(mdev);
 545                 goto out;
 546         }
 547
 548         err = vdpa_mgmtdev_fill(mdev, msg, info->snd_portid, info->snd_seq, 0);
 549         up_read(&vdpa_dev_lock);
 550         if (err)
 551                 goto out;
 552         err = genlmsg_reply(msg, info);
 553         return err;
 554
 555 out:
 556         nlmsg_free(msg);
 557         return err;
 558 }
 559
 560 static int
 561 vdpa_nl_cmd_mgmtdev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
 562 {
 563         struct vdpa_mgmt_dev *mdev;
 564         int start = cb->args[0];
 565         int idx = 0;
 566         int err;
 567
 568         down_read(&vdpa_dev_lock);
 569         list_for_each_entry(mdev, &mdev_head, list) {
 570                 if (idx < start) {
 571                         idx++;
 572                         continue;
 573                 }
 574                 err = vdpa_mgmtdev_fill(mdev, msg, NETLINK_CB(cb->skb).portid,
 575                                         cb->nlh->nlmsg_seq, NLM_F_MULTI);
 576                 if (err)
 577                         goto out;
 578                 idx++;
 579         }
 580 out:
 581         up_read(&vdpa_dev_lock);
 582         cb->args[0] = idx;
 583         return msg->len;
 584 }
 585
 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))
 589
 590 static int vdpa_nl_cmd_dev_add_set_doit(struct sk_buff *skb, struct genl_info *info)
 591 {
 592         struct vdpa_dev_set_config config = {};
 593         struct nlattr **nl_attrs = info->attrs;
 594         struct vdpa_mgmt_dev *mdev;
 595         const u8 *macaddr;
 596         const char *name;
 597         int err = 0;
 598
 599         if (!info->attrs[VDPA_ATTR_DEV_NAME])
 600                 return -EINVAL;
 601
 602         name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
 603
 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);
 608         }
 609         if (nl_attrs[VDPA_ATTR_DEV_NET_CFG_MTU]) {
 610                 config.net.mtu =
 611                         nla_get_u16(nl_attrs[VDPA_ATTR_DEV_NET_CFG_MTU]);
 612                 config.mask |= BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MTU);
 613         }
 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");
 620                         return -EINVAL;
 621                 }
 622                 config.mask |= BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MAX_VQP);
 623         }
 624
 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.
 629          */
 630         if ((config.mask & VDPA_DEV_NET_ATTRS_MASK) &&
 631             !netlink_capable(skb, CAP_NET_ADMIN))
 632                 return -EPERM;
 633
 634         down_write(&vdpa_dev_lock);
 635         mdev = vdpa_mgmtdev_get_from_attr(info->attrs);
 636         if (IS_ERR(mdev)) {
 637                 NL_SET_ERR_MSG_MOD(info->extack, "Fail to find the specified management device");
 638                 err = PTR_ERR(mdev);
 639                 goto err;
 640         }
 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");
 644                 err = -EOPNOTSUPP;
 645                 goto err;
 646         }
 647
 648         err = mdev->ops->dev_add(mdev, name, &config);
 649 err:
 650         up_write(&vdpa_dev_lock);
 651         return err;
 652 }
 653
 654 static int vdpa_nl_cmd_dev_del_set_doit(struct sk_buff *skb, struct genl_info *info)
 655 {
 656         struct vdpa_mgmt_dev *mdev;
 657         struct vdpa_device *vdev;
 658         struct device *dev;
 659         const char *name;
 660         int err = 0;
 661
 662         if (!info->attrs[VDPA_ATTR_DEV_NAME])
 663                 return -EINVAL;
 664         name = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
 665
 666         down_write(&vdpa_dev_lock);
 667         dev = bus_find_device(&vdpa_bus, NULL, name, vdpa_name_match);
 668         if (!dev) {
 669                 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
 670                 err = -ENODEV;
 671                 goto dev_err;
 672         }
 673         vdev = container_of(dev, struct vdpa_device, dev);
 674         if (!vdev->mdev) {
 675                 NL_SET_ERR_MSG_MOD(info->extack, "Only user created device can be deleted by user");
 676                 err = -EINVAL;
 677                 goto mdev_err;
 678         }
 679         mdev = vdev->mdev;
 680         mdev->ops->dev_del(mdev, vdev);
 681 mdev_err:
 682         put_device(dev);
 683 dev_err:
 684         up_write(&vdpa_dev_lock);
 685         return err;
 686 }
 687
 688 static int
 689 vdpa_dev_fill(struct vdpa_device *vdev, struct sk_buff *msg, u32 portid, u32 seq,
 690               int flags, struct netlink_ext_ack *extack)
 691 {
 692         u16 max_vq_size;
 693         u16 min_vq_size = 1;
 694         u32 device_id;
 695         u32 vendor_id;
 696         void *hdr;
 697         int err;
 698
 699         hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags, VDPA_CMD_DEV_NEW);
 700         if (!hdr)
 701                 return -EMSGSIZE;
 702
 703         err = vdpa_nl_mgmtdev_handle_fill(msg, vdev->mdev);
 704         if (err)
 705                 goto msg_err;
 706
 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);
 712
 713         err = -EMSGSIZE;
 714         if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev)))
 715                 goto msg_err;
 716         if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id))
 717                 goto msg_err;
 718         if (nla_put_u32(msg, VDPA_ATTR_DEV_VENDOR_ID, vendor_id))
 719                 goto msg_err;
 720         if (nla_put_u32(msg, VDPA_ATTR_DEV_MAX_VQS, vdev->nvqs))
 721                 goto msg_err;
 722         if (nla_put_u16(msg, VDPA_ATTR_DEV_MAX_VQ_SIZE, max_vq_size))
 723                 goto msg_err;
 724         if (nla_put_u16(msg, VDPA_ATTR_DEV_MIN_VQ_SIZE, min_vq_size))
 725                 goto msg_err;
 726
 727         genlmsg_end(msg, hdr);
 728         return 0;
 729
 730 msg_err:
 731         genlmsg_cancel(msg, hdr);
 732         return err;
 733 }
 734
 735 static int vdpa_nl_cmd_dev_get_doit(struct sk_buff *skb, struct genl_info *info)
 736 {
 737         struct vdpa_device *vdev;
 738         struct sk_buff *msg;
 739         const char *devname;
 740         struct device *dev;
 741         int err;
 742
 743         if (!info->attrs[VDPA_ATTR_DEV_NAME])
 744                 return -EINVAL;
 745         devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
 746         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 747         if (!msg)
 748                 return -ENOMEM;
 749
 750         down_read(&vdpa_dev_lock);
 751         dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match);
 752         if (!dev) {
 753                 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
 754                 err = -ENODEV;
 755                 goto err;
 756         }
 757         vdev = container_of(dev, struct vdpa_device, dev);
 758         if (!vdev->mdev) {
 759                 err = -EINVAL;
 760                 goto mdev_err;
 761         }
 762         err = vdpa_dev_fill(vdev, msg, info->snd_portid, info->snd_seq, 0, info->extack);
 763         if (err)
 764                 goto mdev_err;
 765
 766         err = genlmsg_reply(msg, info);
 767         put_device(dev);
 768         up_read(&vdpa_dev_lock);
 769         return err;
 770
 771 mdev_err:
 772         put_device(dev);
 773 err:
 774         up_read(&vdpa_dev_lock);
 775         nlmsg_free(msg);
 776         return err;
 777 }
 778
 779 struct vdpa_dev_dump_info {
 780         struct sk_buff *msg;
 781         struct netlink_callback *cb;
 782         int start_idx;
 783         int idx;
 784 };
 785
 786 static int vdpa_dev_dump(struct device *dev, void *data)
 787 {
 788         struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
 789         struct vdpa_dev_dump_info *info = data;
 790         int err;
 791
 792         if (!vdev->mdev)
 793                 return 0;
 794         if (info->idx < info->start_idx) {
 795                 info->idx++;
 796                 return 0;
 797         }
 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);
 800         if (err)
 801                 return err;
 802
 803         info->idx++;
 804         return 0;
 805 }
 806
 807 static int vdpa_nl_cmd_dev_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
 808 {
 809         struct vdpa_dev_dump_info info;
 810
 811         info.msg = msg;
 812         info.cb = cb;
 813         info.start_idx = cb->args[0];
 814         info.idx = 0;
 815
 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;
 820         return msg->len;
 821 }
 822
 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)
 826 {
 827         u16 val_u16;
 828
 829         if ((features & BIT_ULL(VIRTIO_NET_F_MQ)) == 0)
 830                 return 0;
 831
 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);
 834 }
 835
 836 static int vdpa_dev_net_config_fill(struct vdpa_device *vdev, struct sk_buff *msg)
 837 {
 838         struct virtio_net_config config = {};
 839         u64 features;
 840         u16 val_u16;
 841
 842         vdpa_get_config_unlocked(vdev, 0, &config, sizeof(config));
 843
 844         if (nla_put(msg, VDPA_ATTR_DEV_NET_CFG_MACADDR, sizeof(config.mac),
 845                     config.mac))
 846                 return -EMSGSIZE;
 847
 848         val_u16 = le16_to_cpu(config.status);
 849         if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_STATUS, val_u16))
 850                 return -EMSGSIZE;
 851
 852         val_u16 = le16_to_cpu(config.mtu);
 853         if (nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MTU, val_u16))
 854                 return -EMSGSIZE;
 855
 856         features = vdev->config->get_driver_features(vdev);
 857         if (nla_put_u64_64bit(msg, VDPA_ATTR_DEV_NEGOTIATED_FEATURES, features,
 858                               VDPA_ATTR_PAD))
 859                 return -EMSGSIZE;
 860
 861         return vdpa_dev_net_mq_config_fill(vdev, msg, features, &config);
 862 }
 863
 864 static int
 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)
 867 {
 868         u32 device_id;
 869         void *hdr;
 870         u8 status;
 871         int err;
 872
 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");
 877                 err = -EAGAIN;
 878                 goto out;
 879         }
 880
 881         hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags,
 882                           VDPA_CMD_DEV_CONFIG_GET);
 883         if (!hdr) {
 884                 err = -EMSGSIZE;
 885                 goto out;
 886         }
 887
 888         if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev))) {
 889                 err = -EMSGSIZE;
 890                 goto msg_err;
 891         }
 892
 893         device_id = vdev->config->get_device_id(vdev);
 894         if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id)) {
 895                 err = -EMSGSIZE;
 896                 goto msg_err;
 897         }
 898
 899         switch (device_id) {
 900         case VIRTIO_ID_NET:
 901                 err = vdpa_dev_net_config_fill(vdev, msg);
 902                 break;
 903         default:
 904                 err = -EOPNOTSUPP;
 905                 break;
 906         }
 907         if (err)
 908                 goto msg_err;
 909
 910         up_read(&vdev->cf_lock);
 911         genlmsg_end(msg, hdr);
 912         return 0;
 913
 914 msg_err:
 915         genlmsg_cancel(msg, hdr);
 916 out:
 917         up_read(&vdev->cf_lock);
 918         return err;
 919 }
 920
 921 static int vdpa_fill_stats_rec(struct vdpa_device *vdev, struct sk_buff *msg,
 922                                struct genl_info *info, u32 index)
 923 {
 924         struct virtio_net_config config = {};
 925         u64 features;
 926         u16 max_vqp;
 927         u8 status;
 928         int err;
 929
 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");
 933                 return -EAGAIN;
 934         }
 935         vdpa_get_config_unlocked(vdev, 0, &config, sizeof(config));
 936
 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))
 939                 return -EMSGSIZE;
 940
 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))
 944                 return -EMSGSIZE;
 945
 946         if (nla_put_u32(msg, VDPA_ATTR_DEV_QUEUE_INDEX, index))
 947                 return -EMSGSIZE;
 948
 949         err = vdev->config->get_vendor_vq_stats(vdev, index, msg, info->extack);
 950         if (err)
 951                 return err;
 952
 953         return 0;
 954 }
 955
 956 static int vendor_stats_fill(struct vdpa_device *vdev, struct sk_buff *msg,
 957                              struct genl_info *info, u32 index)
 958 {
 959         int err;
 960
 961         down_read(&vdev->cf_lock);
 962         if (!vdev->config->get_vendor_vq_stats) {
 963                 err = -EOPNOTSUPP;
 964                 goto out;
 965         }
 966
 967         err = vdpa_fill_stats_rec(vdev, msg, info, index);
 968 out:
 969         up_read(&vdev->cf_lock);
 970         return err;
 971 }
 972
 973 static int vdpa_dev_vendor_stats_fill(struct vdpa_device *vdev,
 974                                       struct sk_buff *msg,
 975                                       struct genl_info *info, u32 index)
 976 {
 977         u32 device_id;
 978         void *hdr;
 979         int err;
 980         u32 portid = info->snd_portid;
 981         u32 seq = info->snd_seq;
 982         u32 flags = 0;
 983
 984         hdr = genlmsg_put(msg, portid, seq, &vdpa_nl_family, flags,
 985                           VDPA_CMD_DEV_VSTATS_GET);
 986         if (!hdr)
 987                 return -EMSGSIZE;
 988
 989         if (nla_put_string(msg, VDPA_ATTR_DEV_NAME, dev_name(&vdev->dev))) {
 990                 err = -EMSGSIZE;
 991                 goto undo_msg;
 992         }
 993
 994         device_id = vdev->config->get_device_id(vdev);
 995         if (nla_put_u32(msg, VDPA_ATTR_DEV_ID, device_id)) {
 996                 err = -EMSGSIZE;
 997                 goto undo_msg;
 998         }
 999
1000         switch (device_id) {
1001         case VIRTIO_ID_NET:
1002                 if (index > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX) {
1003                         NL_SET_ERR_MSG_MOD(info->extack, "queue index excceeds max value");
1004                         err = -ERANGE;
1005                         break;
1006                 }
1007
1008                 err = vendor_stats_fill(vdev, msg, info, index);
1009                 break;
1010         default:
1011                 err = -EOPNOTSUPP;
1012                 break;
1013         }
1014         genlmsg_end(msg, hdr);
1015
1016         return err;
1017
1018 undo_msg:
1019         genlmsg_cancel(msg, hdr);
1020         return err;
1021 }
1022
1023 static int vdpa_nl_cmd_dev_config_get_doit(struct sk_buff *skb, struct genl_info *info)
1024 {
1025         struct vdpa_device *vdev;
1026         struct sk_buff *msg;
1027         const char *devname;
1028         struct device *dev;
1029         int err;
1030
1031         if (!info->attrs[VDPA_ATTR_DEV_NAME])
1032                 return -EINVAL;
1033         devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
1034         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1035         if (!msg)
1036                 return -ENOMEM;
1037
1038         down_read(&vdpa_dev_lock);
1039         dev = bus_find_device(&vdpa_bus, NULL, devname, vdpa_name_match);
1040         if (!dev) {
1041                 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
1042                 err = -ENODEV;
1043                 goto dev_err;
1044         }
1045         vdev = container_of(dev, struct vdpa_device, dev);
1046         if (!vdev->mdev) {
1047                 NL_SET_ERR_MSG_MOD(info->extack, "unmanaged vdpa device");
1048                 err = -EINVAL;
1049                 goto mdev_err;
1050         }
1051         err = vdpa_dev_config_fill(vdev, msg, info->snd_portid, info->snd_seq,
1052                                    0, info->extack);
1053         if (!err)
1054                 err = genlmsg_reply(msg, info);
1055
1056 mdev_err:
1057         put_device(dev);
1058 dev_err:
1059         up_read(&vdpa_dev_lock);
1060         if (err)
1061                 nlmsg_free(msg);
1062         return err;
1063 }
1064
1065 static int vdpa_dev_config_dump(struct device *dev, void *data)
1066 {
1067         struct vdpa_device *vdev = container_of(dev, struct vdpa_device, dev);
1068         struct vdpa_dev_dump_info *info = data;
1069         int err;
1070
1071         if (!vdev->mdev)
1072                 return 0;
1073         if (info->idx < info->start_idx) {
1074                 info->idx++;
1075                 return 0;
1076         }
1077         err = vdpa_dev_config_fill(vdev, info->msg, NETLINK_CB(info->cb->skb).portid,
1078                                    info->cb->nlh->nlmsg_seq, NLM_F_MULTI,
1079                                    info->cb->extack);
1080         if (err)
1081                 return err;
1082
1083         info->idx++;
1084         return 0;
1085 }
1086
1087 static int
1088 vdpa_nl_cmd_dev_config_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
1089 {
1090         struct vdpa_dev_dump_info info;
1091
1092         info.msg = msg;
1093         info.cb = cb;
1094         info.start_idx = cb->args[0];
1095         info.idx = 0;
1096
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;
1101         return msg->len;
1102 }
1103
1104 static int vdpa_nl_cmd_dev_stats_get_doit(struct sk_buff *skb,
1105                                           struct genl_info *info)
1106 {
1107         struct vdpa_device *vdev;
1108         struct sk_buff *msg;
1109         const char *devname;
1110         struct device *dev;
1111         u32 index;
1112         int err;
1113
1114         if (!info->attrs[VDPA_ATTR_DEV_NAME])
1115                 return -EINVAL;
1116
1117         if (!info->attrs[VDPA_ATTR_DEV_QUEUE_INDEX])
1118                 return -EINVAL;
1119
1120         devname = nla_data(info->attrs[VDPA_ATTR_DEV_NAME]);
1121         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1122         if (!msg)
1123                 return -ENOMEM;
1124
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);
1128         if (!dev) {
1129                 NL_SET_ERR_MSG_MOD(info->extack, "device not found");
1130                 err = -ENODEV;
1131                 goto dev_err;
1132         }
1133         vdev = container_of(dev, struct vdpa_device, dev);
1134         if (!vdev->mdev) {
1135                 NL_SET_ERR_MSG_MOD(info->extack, "unmanaged vdpa device");
1136                 err = -EINVAL;
1137                 goto mdev_err;
1138         }
1139         err = vdpa_dev_vendor_stats_fill(vdev, msg, info, index);
1140         if (err)
1141                 goto mdev_err;
1142
1143         err = genlmsg_reply(msg, info);
1144
1145         put_device(dev);
1146         up_read(&vdpa_dev_lock);
1147
1148         return err;
1149
1150 mdev_err:
1151         put_device(dev);
1152 dev_err:
1153         nlmsg_free(msg);
1154         up_read(&vdpa_dev_lock);
1155         return err;
1156 }
1157
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),
1165 };
1166
1167 static const struct genl_ops vdpa_nl_ops[] = {
1168         {
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,
1173         },
1174         {
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,
1179         },
1180         {
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,
1185         },
1186         {
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,
1191         },
1192         {
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,
1197         },
1198         {
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,
1203         },
1204 };
1205
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,
1211         .netnsok = false,
1212         .module = THIS_MODULE,
1213         .ops = vdpa_nl_ops,
1214         .n_ops = ARRAY_SIZE(vdpa_nl_ops),
1215 };
1216
1217 static int vdpa_init(void)
1218 {
1219         int err;
1220
1221         err = bus_register(&vdpa_bus);
1222         if (err)
1223                 return err;
1224         err = genl_register_family(&vdpa_nl_family);
1225         if (err)
1226                 goto err;
1227         return 0;
1228
1229 err:
1230         bus_unregister(&vdpa_bus);
1231         return err;
1232 }
1233
1234 static void __exit vdpa_exit(void)
1235 {
1236         genl_unregister_family(&vdpa_nl_family);
1237         bus_unregister(&vdpa_bus);
1238         ida_destroy(&vdpa_index_ida);
1239 }
1240 core_initcall(vdpa_init);
1241 module_exit(vdpa_exit);
1242
1243 MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>");
1244 MODULE_LICENSE("GPL v2");