Release 4.11 drivers/vfio/mdev/mdev_core.c

Directory: drivers/vfio/mdev
/*
 * Mediated device Core Driver
 *
 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
 *     Author: Neo Jia <cjia@nvidia.com>
 *             Kirti Wankhede <kwankhede@nvidia.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include <linux/sysfs.h>
#include <linux/mdev.h>

#include "mdev_private.h"


#define DRIVER_VERSION		"0.1"

#define DRIVER_AUTHOR		"NVIDIA Corporation"

#define DRIVER_DESC		"Mediated device Core Driver"

static LIST_HEAD(parent_list);
static DEFINE_MUTEX(parent_list_lock);

static struct class_compat *mdev_bus_compat_class;

static LIST_HEAD(mdev_list);
static DEFINE_MUTEX(mdev_list_lock);



struct device *mdev_parent_dev(struct mdev_device *mdev)
{
	return mdev->parent->dev;
}
Contributors
Person Tokens Prop Commits CommitProp
Alex Williamson 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%


EXPORT_SYMBOL(mdev_parent_dev);



void *mdev_get_drvdata(struct mdev_device *mdev)
{
	return mdev->driver_data;
}
Contributors
Person Tokens Prop Commits CommitProp
Alex Williamson 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


EXPORT_SYMBOL(mdev_get_drvdata);



void mdev_set_drvdata(struct mdev_device *mdev, void *data)
{
	mdev->driver_data = data;
}
Contributors
Person Tokens Prop Commits CommitProp
Alex Williamson 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%


EXPORT_SYMBOL(mdev_set_drvdata);



struct device *mdev_dev(struct mdev_device *mdev)
{
	return &mdev->dev;
}
Contributors
Person Tokens Prop Commits CommitProp
Alex Williamson 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL(mdev_dev);



struct mdev_device *mdev_from_dev(struct device *dev)
{
	return dev_is_mdev(dev) ? to_mdev_device(dev) : NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Alex Williamson 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


EXPORT_SYMBOL(mdev_from_dev);



uuid_le mdev_uuid(struct mdev_device *mdev)
{
	return mdev->uuid;
}
Contributors
Person Tokens Prop Commits CommitProp
Alex Williamson 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


EXPORT_SYMBOL(mdev_uuid);



static int _find_mdev_device(struct device *dev, void *data)
{
	struct mdev_device *mdev;

	if (!dev_is_mdev(dev))
		return 0;

	mdev = to_mdev_device(dev);

	if (uuid_le_cmp(mdev->uuid, *(uuid_le *)data) == 0)
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 62 100.00% 1 100.00%
Total 62 100.00% 1 100.00%



static bool mdev_device_exist(struct mdev_parent *parent, uuid_le uuid)
{
	struct device *dev;

	dev = device_find_child(parent->dev, &uuid, _find_mdev_device);
	if (dev) {
		put_device(dev);
		return true;
	}

	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 49 98.00% 1 50.00%
Alex Williamson 1 2.00% 1 50.00%
Total 50 100.00% 2 100.00%

/* Should be called holding parent_list_lock */


static struct mdev_parent *__find_parent_device(struct device *dev)
{
	struct mdev_parent *parent;

	list_for_each_entry(parent, &parent_list, next) {
		if (parent->dev == dev)
			return parent;
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 40 95.24% 1 50.00%
Alex Williamson 2 4.76% 1 50.00%
Total 42 100.00% 2 100.00%



static void mdev_release_parent(struct kref *kref)
{
	struct mdev_parent *parent = container_of(kref, struct mdev_parent,
						  ref);
	struct device *dev = parent->dev;

	kfree(parent);
	put_device(dev);
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 43 95.56% 1 50.00%
Alex Williamson 2 4.44% 1 50.00%
Total 45 100.00% 2 100.00%


static

inline struct mdev_parent *mdev_get_parent(struct mdev_parent *parent)
{
	if (parent)
		kref_get(&parent->ref);

	return parent;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 27 93.10% 1 50.00%
Alex Williamson 2 6.90% 1 50.00%
Total 29 100.00% 2 100.00%



static inline void mdev_put_parent(struct mdev_parent *parent)
{
	if (parent)
		kref_put(&parent->ref, mdev_release_parent);
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 25 96.15% 1 50.00%
Alex Williamson 1 3.85% 1 50.00%
Total 26 100.00% 2 100.00%



static int mdev_device_create_ops(struct kobject *kobj,
				  struct mdev_device *mdev)
{
	struct mdev_parent *parent = mdev->parent;
	int ret;

	ret = parent->ops->create(kobj, mdev);
	if (ret)
		return ret;

	ret = sysfs_create_groups(&mdev->dev.kobj,
				  parent->ops->mdev_attr_groups);
	if (ret)
		parent->ops->remove(mdev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 81 98.78% 1 50.00%
Alex Williamson 1 1.22% 1 50.00%
Total 82 100.00% 2 100.00%

/*
 * mdev_device_remove_ops gets called from sysfs's 'remove' and when parent
 * device is being unregistered from mdev device framework.
 * - 'force_remove' is set to 'false' when called from sysfs's 'remove' which
 *   indicates that if the mdev device is active, used by VMM or userspace
 *   application, vendor driver could return error then don't remove the device.
 * - 'force_remove' is set to 'true' when called from mdev_unregister_device()
 *   which indicate that parent device is being removed from mdev device
 *   framework so remove mdev device forcefully.
 */


static int mdev_device_remove_ops(struct mdev_device *mdev, bool force_remove)
{
	struct mdev_parent *parent = mdev->parent;
	int ret;

	/*
         * Vendor driver can return error if VMM or userspace application is
         * using this mdev device.
         */
	ret = parent->ops->remove(mdev);
	if (ret && !force_remove)
		return -EBUSY;

	sysfs_remove_groups(&mdev->dev.kobj, parent->ops->mdev_attr_groups);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 67 98.53% 1 50.00%
Alex Williamson 1 1.47% 1 50.00%
Total 68 100.00% 2 100.00%



static int mdev_device_remove_cb(struct device *dev, void *data)
{
	if (!dev_is_mdev(dev))
		return 0;

	return mdev_device_remove(dev, data ? *(bool *)data : true);
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%

/*
 * mdev_register_device : Register a device
 * @dev: device structure representing parent device.
 * @ops: Parent device operation structure to be registered.
 *
 * Add device to list of registered parent devices.
 * Returns a negative value on error, otherwise 0.
 */


int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops)
{
	int ret;
	struct mdev_parent *parent;

	/* check for mandatory ops */
	if (!ops || !ops->create || !ops->remove || !ops->supported_type_groups)
		return -EINVAL;

	dev = get_device(dev);
	if (!dev)
		return -EINVAL;

	mutex_lock(&parent_list_lock);

	/* Check for duplicate */
	parent = __find_parent_device(dev);
	if (parent) {
		ret = -EEXIST;
		goto add_dev_err;
	}

	parent = kzalloc(sizeof(*parent), GFP_KERNEL);
	if (!parent) {
		ret = -ENOMEM;
		goto add_dev_err;
	}

	kref_init(&parent->ref);
	mutex_init(&parent->lock);

	parent->dev = dev;
	parent->ops = ops;

	if (!mdev_bus_compat_class) {
		mdev_bus_compat_class = class_compat_register("mdev_bus");
		if (!mdev_bus_compat_class) {
			ret = -ENOMEM;
			goto add_dev_err;
		}
	}

	ret = parent_create_sysfs_files(parent);
	if (ret)
		goto add_dev_err;

	ret = class_compat_create_link(mdev_bus_compat_class, dev, NULL);
	if (ret)
		dev_warn(dev, "Failed to create compatibility class link\n");

	list_add(&parent->next, &parent_list);
	mutex_unlock(&parent_list_lock);

	dev_info(dev, "MDEV: Registered\n");
	return 0;

add_dev_err:
	mutex_unlock(&parent_list_lock);
	if (parent)
		mdev_put_parent(parent);
	else
		put_device(dev);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 265 99.25% 1 50.00%
Alex Williamson 2 0.75% 1 50.00%
Total 267 100.00% 2 100.00%


EXPORT_SYMBOL(mdev_register_device);

/*
 * mdev_unregister_device : Unregister a parent device
 * @dev: device structure representing parent device.
 *
 * Remove device from list of registered parent devices. Give a chance to free
 * existing mediated devices for given device.
 */



void mdev_unregister_device(struct device *dev)
{
	struct mdev_parent *parent;
	bool force_remove = true;

	mutex_lock(&parent_list_lock);
	parent = __find_parent_device(dev);

	if (!parent) {
		mutex_unlock(&parent_list_lock);
		return;
	}
	dev_info(dev, "MDEV: Unregistering\n");

	list_del(&parent->next);
	class_compat_remove_link(mdev_bus_compat_class, dev, NULL);

	device_for_each_child(dev, (void *)&force_remove,
			      mdev_device_remove_cb);

	parent_remove_sysfs_files(parent);

	mutex_unlock(&parent_list_lock);
	mdev_put_parent(parent);
}
Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 100 99.01% 1 50.00%
Alex Williamson 1 0.99% 1 50.00%
Total 101 100.00% 2 100.00%


EXPORT_SYMBOL(mdev_unregister_device);



static void mdev_device_release(struct device *dev)
{
	struct mdev_device *mdev = to_mdev_device(dev);

	dev_dbg(&mdev->dev, "MDEV: destroying\n");
	kfree(mdev);
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



int mdev_device_create(struct kobject *kobj, struct device *dev, uuid_le uuid)
{
	int ret;
	struct mdev_device *mdev;
	struct mdev_parent *parent;
	struct mdev_type *type = to_mdev_type(kobj);

	parent = mdev_get_parent(type->parent);
	if (!parent)
		return -EINVAL;

	mutex_lock(&parent->lock);

	/* Check for duplicate */
	if (mdev_device_exist(parent, uuid)) {
		ret = -EEXIST;
		goto create_err;
	}

	mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
	if (!mdev) {
		ret = -ENOMEM;
		goto create_err;
	}

	memcpy(&mdev->uuid, &uuid, sizeof(uuid_le));
	mdev->parent = parent;
	kref_init(&mdev->ref);

	mdev->dev.parent  = dev;
	mdev->dev.bus     = &mdev_bus_type;
	mdev->dev.release = mdev_device_release;
	dev_set_name(&mdev->dev, "%pUl", uuid.b);

	ret = device_register(&mdev->dev);
	if (ret) {
		put_device(&mdev->dev);
		goto create_err;
	}

	ret = mdev_device_create_ops(kobj, mdev);
	if (ret)
		goto create_failed;

	ret = mdev_create_sysfs_files(&mdev->dev, type);
	if (ret) {
		mdev_device_remove_ops(mdev, true);
		goto create_failed;
	}

	mdev->type_kobj = kobj;
	dev_dbg(&mdev->dev, "MDEV: created\n");

	mutex_unlock(&parent->lock);

	mutex_lock(&mdev_list_lock);
	list_add(&mdev->next, &mdev_list);
	mutex_unlock(&mdev_list_lock);

	return ret;

create_failed:
	device_unregister(&mdev->dev);

create_err:
	mutex_unlock(&parent->lock);
	mdev_put_parent(parent);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 309 92.79% 1 33.33%
Alex Williamson 24 7.21% 2 66.67%
Total 333 100.00% 3 100.00%



int mdev_device_remove(struct device *dev, bool force_remove)
{
	struct mdev_device *mdev, *tmp;
	struct mdev_parent *parent;
	struct mdev_type *type;
	int ret;
	bool found = false;

	mdev = to_mdev_device(dev);

	mutex_lock(&mdev_list_lock);
	list_for_each_entry(tmp, &mdev_list, next) {
		if (tmp == mdev) {
			found = true;
			break;
		}
	}

	if (found)
		list_del(&mdev->next);

	mutex_unlock(&mdev_list_lock);

	if (!found)
		return -ENODEV;

	type = to_mdev_type(mdev->type_kobj);
	parent = mdev->parent;
	mutex_lock(&parent->lock);

	ret = mdev_device_remove_ops(mdev, force_remove);
	if (ret) {
		mutex_unlock(&parent->lock);

		mutex_lock(&mdev_list_lock);
		list_add(&mdev->next, &mdev_list);
		mutex_unlock(&mdev_list_lock);

		return ret;
	}

	mdev_remove_sysfs_files(dev, type);
	device_unregister(dev);
	mutex_unlock(&parent->lock);
	mdev_put_parent(parent);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 113 55.94% 1 33.33%
Alex Williamson 89 44.06% 2 66.67%
Total 202 100.00% 3 100.00%



static int __init mdev_init(void)
{
	return mdev_bus_register();
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 12 92.31% 1 50.00%
Alex Williamson 1 7.69% 1 50.00%
Total 13 100.00% 2 100.00%



static void __exit mdev_exit(void)
{
	if (mdev_bus_compat_class)
		class_compat_unregister(mdev_bus_compat_class);

	mdev_bus_unregister();
}

Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

module_init(mdev_init)
module_exit(mdev_exit)

MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL v2");

MODULE_AUTHOR(DRIVER_AUTHOR);

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_SOFTDEP("post: vfio_mdev");
Overall Contributors
Person Tokens Prop Commits CommitProp
Kirti Wankhede 1387 82.86% 1 16.67%
Alex Williamson 287 17.14% 5 83.33%
Total 1674 100.00% 6 100.00%
Directory: drivers/vfio/mdev

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Alex Williamson	19	100.00%	1	100.00%
Total	19	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 drivers/vfio/mdev/mdev_core.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
