drm/vkms: Add and remove VKMS instances via configfs

Allow to create, enable, disable and destroy VKMS instances using
configfs.

For the moment, it is not possible to add pipeline items, so trying to
enable the device will fail printing an informative error to the log.

Tested-by: Mark Yacoub <markyacoub@google.com>
Reviewed-by: Louis Chauvet <louis.chauvet@bootlin.com>
Reviewed-by: Harry Wentland <harry.wentland@amd.com>
Reviewed-by: Luca Ceresoli <luca.ceresoli@bootlin.com>
Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
Co-developed-by: José Expósito <jose.exposito89@gmail.com>
Signed-off-by: José Expósito <jose.exposito89@gmail.com>
Link: https://lore.kernel.org/r/20251016175618.10051-3-jose.exposito89@gmail.com
Signed-off-by: Luca Ceresoli <luca.ceresoli@bootlin.com>

diff --git a/Documentation/gpu/vkms.rst b/Documentation/gpu/vkms.rst
index 8a8b1002931f81366595b935ae145661b171fc2d..73521b9ff0c3080dabb6c844a74477708f92c746 100644 (file)
--- a/Documentation/gpu/vkms.rst
+++ b/Documentation/gpu/vkms.rst
@@ -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
 ================
 

diff --git a/drivers/gpu/drm/vkms/Kconfig b/drivers/gpu/drm/vkms/Kconfig
index 3c02f928ffe6bbe9494676fc65a94fbb1c44d5e3..3977bbb99f7d803ededca1b2dd6185176502298f 100644 (file)
--- a/drivers/gpu/drm/vkms/Kconfig
+++ b/drivers/gpu/drm/vkms/Kconfig
@@ -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

diff --git a/drivers/gpu/drm/vkms/Makefile b/drivers/gpu/drm/vkms/Makefile
index d657865e573f3e2002fa35fe72b9dc4b8261468d..939991fc8233656004ad1b99ab28cf61a6cb0df8 100644 (file)
--- a/drivers/gpu/drm/vkms/Makefile
+++ b/drivers/gpu/drm/vkms/Makefile
@@ -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/

diff --git a/drivers/gpu/drm/vkms/vkms_configfs.c b/drivers/gpu/drm/vkms/vkms_configfs.c
new file mode 100644 (file)
index 0000000..ee18695
--- /dev/null
+++ b/drivers/gpu/drm/vkms/vkms_configfs.c
@@ -0,0 +1,172 @@
+// 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);
+}

diff --git a/drivers/gpu/drm/vkms/vkms_configfs.h b/drivers/gpu/drm/vkms/vkms_configfs.h
new file mode 100644 (file)
index 0000000..e9020b0
--- /dev/null
+++ b/drivers/gpu/drm/vkms/vkms_configfs.h
@@ -0,0 +1,8 @@
+/* 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_ */

diff --git a/drivers/gpu/drm/vkms/vkms_drv.c b/drivers/gpu/drm/vkms/vkms_drv.c
index 78af37c7bd833e9a923769f068813dc77676b056..c1f23e6a4b076140fba7d1f66ad78ab1fad16cb6 100644 (file)
--- a/drivers/gpu/drm/vkms/vkms_drv.c
+++ b/drivers/gpu/drm/vkms/vkms_drv.c
@@ -28,6 +28,7 @@
 #include <drm/drm_vblank.h>
 
 #include "vkms_config.h"
+#include "vkms_configfs.h"
 #include "vkms_drv.h"
 
 #define DRIVER_NAME    "vkms"
@@ -214,6 +215,10 @@ static int __init vkms_init(void)
        int ret;
        struct vkms_config *config;
 
+       ret = vkms_configfs_register();
+       if (ret)
+               return ret;
+
        config = vkms_config_default_create(enable_cursor, enable_writeback, enable_overlay);
        if (IS_ERR(config))
                return PTR_ERR(config);
@@ -250,6 +255,8 @@ void vkms_destroy(struct vkms_config *config)
 
 static void __exit vkms_exit(void)
 {
+       vkms_configfs_unregister();
+
        if (!default_config)
                return;