drm/vkms: Add and remove VKMS instances via configfs (13fc9b97) · Commits · git / linux-net

Documentation/gpu/vkms.rst

+32 −0

Original line number	Diff line number	Diff line
		@@ -51,6 +51,38 @@ To disable the driver, use ::

		sudo modprobe -r vkms

		Configuring With Configfs
		=========================

		It is possible to create and configure multiple VKMS instances via configfs.

		Start by mounting configfs and loading VKMS::

		sudo mount -t configfs none /config
		sudo modprobe vkms

		Once VKMS is loaded, ``/config/vkms`` is created automatically. Each directory
		under ``/config/vkms`` represents a VKMS instance, create a new one::

		sudo mkdir /config/vkms/my-vkms

		By default, the instance is disabled::

		cat /config/vkms/my-vkms/enabled
		0

		Once you are done configuring the VKMS instance, enable it::

		echo "1" \| sudo tee /config/vkms/my-vkms/enabled

		Finally, you can remove the VKMS instance disabling it::

		echo "0" \| sudo tee /config/vkms/my-vkms/enabled

		And removing the top level directory::

		sudo rmdir /config/vkms/my-vkms

		Testing With IGT
		================

drivers/gpu/drm/vkms/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@ config DRM_VKMS
		select DRM_KMS_HELPER
		select DRM_GEM_SHMEM_HELPER
		select CRC32
		select CONFIGFS_FS
		default n
		help
		Virtual Kernel Mode-Setting (VKMS) is used for testing or for

drivers/gpu/drm/vkms/Makefile

+2 −1

Original line number	Diff line number	Diff line
		@@ -8,7 +8,8 @@ vkms-y := \
		vkms_composer.o \
		vkms_writeback.o \
		vkms_connector.o \
		vkms_config.o
		vkms_config.o \
		vkms_configfs.o

		obj-$(CONFIG_DRM_VKMS) += vkms.o
		obj-$(CONFIG_DRM_VKMS_KUNIT_TEST) += tests/

drivers/gpu/drm/vkms/vkms_configfs.c

0 → 100644

+172 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0+
		#include <linux/cleanup.h>
		#include <linux/configfs.h>
		#include <linux/mutex.h>
		#include <linux/slab.h>

		#include "vkms_drv.h"
		#include "vkms_config.h"
		#include "vkms_configfs.h"

		/* To avoid registering configfs more than once or unregistering on error */
		static bool is_configfs_registered;

		/**
		* struct vkms_configfs_device - Configfs representation of a VKMS device
		*
		* @group: Top level configuration group that represents a VKMS device.
		* Initialized when a new directory is created under "/config/vkms/"
		* @lock: Lock used to project concurrent access to the configuration attributes
		* @config: Protected by @lock. Configuration of the VKMS device
		* @enabled: Protected by @lock. The device is created or destroyed when this
		* option changes
		*/
		struct vkms_configfs_device {
		struct config_group group;

		struct mutex lock;
		struct vkms_config *config;
		bool enabled;
		};

		#define device_item_to_vkms_configfs_device(item) \
		container_of(to_config_group((item)), struct vkms_configfs_device, \
		group)

		static ssize_t device_enabled_show(struct config_item item, char page)
		{
		struct vkms_configfs_device *dev;
		bool enabled;

		dev = device_item_to_vkms_configfs_device(item);

		scoped_guard(mutex, &dev->lock)
		enabled = dev->enabled;

		return sprintf(page, "%d\n", enabled);
		}

		static ssize_t device_enabled_store(struct config_item item, const char page,
		size_t count)
		{
		struct vkms_configfs_device *dev;
		bool enabled;
		int ret = 0;

		dev = device_item_to_vkms_configfs_device(item);

		if (kstrtobool(page, &enabled))
		return -EINVAL;

		scoped_guard(mutex, &dev->lock) {
		if (!dev->enabled && enabled) {
		if (!vkms_config_is_valid(dev->config))
		return -EINVAL;

		ret = vkms_create(dev->config);
		if (ret)
		return ret;
		} else if (dev->enabled && !enabled) {
		vkms_destroy(dev->config);
		}

		dev->enabled = enabled;
		}

		return (ssize_t)count;
		}

		CONFIGFS_ATTR(device_, enabled);

		static struct configfs_attribute *device_item_attrs[] = {
		&device_attr_enabled,
		NULL,
		};

		static void device_release(struct config_item *item)
		{
		struct vkms_configfs_device *dev;

		dev = device_item_to_vkms_configfs_device(item);

		if (dev->enabled)
		vkms_destroy(dev->config);

		mutex_destroy(&dev->lock);
		vkms_config_destroy(dev->config);
		kfree(dev);
		}

		static struct configfs_item_operations device_item_operations = {
		.release = &device_release,
		};

		static const struct config_item_type device_item_type = {
		.ct_attrs = device_item_attrs,
		.ct_item_ops = &device_item_operations,
		.ct_owner = THIS_MODULE,
		};

		static struct config_group make_device_group(struct config_group group,
		const char *name)
		{
		struct vkms_configfs_device *dev;

		if (strcmp(name, DEFAULT_DEVICE_NAME) == 0)
		return ERR_PTR(-EINVAL);

		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
		if (!dev)
		return ERR_PTR(-ENOMEM);

		dev->config = vkms_config_create(name);
		if (IS_ERR(dev->config)) {
		kfree(dev);
		return ERR_CAST(dev->config);
		}

		config_group_init_type_name(&dev->group, name, &device_item_type);
		mutex_init(&dev->lock);

		return &dev->group;
		}

		static struct configfs_group_operations device_group_ops = {
		.make_group = &make_device_group,
		};

		static const struct config_item_type device_group_type = {
		.ct_group_ops = &device_group_ops,
		.ct_owner = THIS_MODULE,
		};

		static struct configfs_subsystem vkms_subsys = {
		.su_group = {
		.cg_item = {
		.ci_name = "vkms",
		.ci_type = &device_group_type,
		},
		},
		.su_mutex = __MUTEX_INITIALIZER(vkms_subsys.su_mutex),
		};

		int vkms_configfs_register(void)
		{
		int ret;

		if (is_configfs_registered)
		return 0;

		config_group_init(&vkms_subsys.su_group);
		ret = configfs_register_subsystem(&vkms_subsys);

		is_configfs_registered = ret == 0;

		return ret;
		}

		void vkms_configfs_unregister(void)
		{
		if (is_configfs_registered)
		configfs_unregister_subsystem(&vkms_subsys);
		}

drivers/gpu/drm/vkms/vkms_configfs.h

0 → 100644

+8 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0+ */
		#ifndef _VKMS_CONFIGFS_H_
		#define _VKMS_CONFIGFS_H_

		int vkms_configfs_register(void);
		void vkms_configfs_unregister(void);

		#endif /* _VKMS_CONFIGFS_H_ */