[PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Javier Martinez Canillas]

Hello,

The patches in this series are mostly changes suggested by Daniel Vetter
to fix some race conditions that exists between the fbdev core (fbmem)
and sysfb with regard to device registration and removal.

For example, it is currently possible for sysfb to register a platform
device after a real DRM driver was registered and requested to remove the
conflicting framebuffers.

A symptom of this issue, was worked around with by commit fb561bf9abde
("fbdev: Prevent probing generic drivers if a FB is already registered")
but that's really a hack and should be reverted.

This series attempt to fix it more properly and revert the mentioned hack.
That will also unblock a pending patch to not make the num_registered_fb
variable visible to drivers anymore, since that's internal to fbdev core.

Patch #1 is just a trivial preparatory change.

Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
to use them.

Patch #3 changes how is dealt with conflicting framebuffers unregistering,
rather than having a variable to determine if a lock should be take, it
just drops the lock before unregistering the platform device.

Patch #4 fixes the mentioned race conditions and finally patch #5 is the
revert patch that was posted by Daniel before but he dropped from his set.

The patches were tested on a rpi4 using different video configurations:
(simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
and simpledrm builtin with vc4 built as a module).

Best regards,
Javier

Changes in v3:
- Rebase on top of latest drm-misc-next branch.

Changes in v2:
- Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).
- Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).
- Explain in the commit message that fbmem has to unregister the device
  as fallback if a driver registered the device itself (Daniel Vetter).
- Also explain that fallback in a comment in the code (Daniel Vetter).
- Don't encode in fbmem the assumption that sysfb will always register
  platform devices (Daniel Vetter).
- Add a FIXME comment about drivers registering devices (Daniel Vetter).
- Drop RFC prefix since patches were already reviewed by Daniel Vetter.
- Add Daniel Reviewed-by tags to the patches.

Daniel Vetter (1):
  Revert "fbdev: Prevent probing generic drivers if a FB is already
    registered"

Javier Martinez Canillas (4):
  firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer
  firmware: sysfb: Add helpers to unregister a pdev and disable
    registration
  fbdev: Restart conflicting fb removal loop when unregistering devices
  fbdev: Fix some race conditions between fbmem and sysfb

 .../driver-api/firmware/other_interfaces.rst  |  6 ++
 drivers/firmware/sysfb.c                      | 77 +++++++++++++++++--
 drivers/firmware/sysfb_simplefb.c             | 16 ++--
 drivers/video/fbdev/core/fbmem.c              | 62 ++++++++++++---
 drivers/video/fbdev/efifb.c                   | 11 ---
 drivers/video/fbdev/simplefb.c                | 11 ---
 include/linux/fb.h                            |  1 -
 include/linux/sysfb.h                         | 29 +++++--
 8 files changed, 158 insertions(+), 55 deletions(-)

-- 
2.35.1

[PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Javier Martinez Canillas]

Hello,

The patches in this series are mostly changes suggested by Daniel Vetter
to fix some race conditions that exists between the fbdev core (fbmem)
and sysfb with regard to device registration and removal.

For example, it is currently possible for sysfb to register a platform
device after a real DRM driver was registered and requested to remove the
conflicting framebuffers.

A symptom of this issue, was worked around with by commit fb561bf9abde
("fbdev: Prevent probing generic drivers if a FB is already registered")
but that's really a hack and should be reverted.

This series attempt to fix it more properly and revert the mentioned hack.
That will also unblock a pending patch to not make the num_registered_fb
variable visible to drivers anymore, since that's internal to fbdev core.

Patch #1 is just a trivial preparatory change.

Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
to use them.

Patch #3 changes how is dealt with conflicting framebuffers unregistering,
rather than having a variable to determine if a lock should be take, it
just drops the lock before unregistering the platform device.

Patch #4 fixes the mentioned race conditions and finally patch #5 is the
revert patch that was posted by Daniel before but he dropped from his set.

The patches were tested on a rpi4 using different video configurations:
(simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
and simpledrm builtin with vc4 built as a module).

Best regards,
Javier

Changes in v3:
- Rebase on top of latest drm-misc-next branch.

Changes in v2:
- Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).
- Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).
- Explain in the commit message that fbmem has to unregister the device
  as fallback if a driver registered the device itself (Daniel Vetter).
- Also explain that fallback in a comment in the code (Daniel Vetter).
- Don't encode in fbmem the assumption that sysfb will always register
  platform devices (Daniel Vetter).
- Add a FIXME comment about drivers registering devices (Daniel Vetter).
- Drop RFC prefix since patches were already reviewed by Daniel Vetter.
- Add Daniel Reviewed-by tags to the patches.

Daniel Vetter (1):
  Revert "fbdev: Prevent probing generic drivers if a FB is already
    registered"

Javier Martinez Canillas (4):
  firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer
  firmware: sysfb: Add helpers to unregister a pdev and disable
    registration
  fbdev: Restart conflicting fb removal loop when unregistering devices
  fbdev: Fix some race conditions between fbmem and sysfb

 .../driver-api/firmware/other_interfaces.rst  |  6 ++
 drivers/firmware/sysfb.c                      | 77 +++++++++++++++++--
 drivers/firmware/sysfb_simplefb.c             | 16 ++--
 drivers/video/fbdev/core/fbmem.c              | 62 ++++++++++++---
 drivers/video/fbdev/efifb.c                   | 11 ---
 drivers/video/fbdev/simplefb.c                | 11 ---
 include/linux/fb.h                            |  1 -
 include/linux/sysfb.h                         | 29 +++++--
 8 files changed, 158 insertions(+), 55 deletions(-)

-- 
2.35.1

[PATCH v3 1/5] firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer

[Javier Martinez Canillas]

This function just returned 0 on success or an errno code on error, but it
could be useful for sysfb_init() callers to have a pointer to the device.

Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v2)

Changes in v2:
- Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).

 drivers/firmware/sysfb.c          |  4 ++--
 drivers/firmware/sysfb_simplefb.c | 16 ++++++++--------
 include/linux/sysfb.h             | 10 +++++-----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
index 2bfbb05f7d89..b032f40a92de 100644
--- a/drivers/firmware/sysfb.c
+++ b/drivers/firmware/sysfb.c
@@ -46,8 +46,8 @@ static __init int sysfb_init(void)
 	/* try to create a simple-framebuffer device */
 	compatible = sysfb_parse_mode(si, &mode);
 	if (compatible) {
-		ret = sysfb_create_simplefb(si, &mode);
-		if (!ret)
+		pd = sysfb_create_simplefb(si, &mode);
+		if (!IS_ERR(pd))
 			return 0;
 	}
 
diff --git a/drivers/firmware/sysfb_simplefb.c b/drivers/firmware/sysfb_simplefb.c
index bda8712bfd8c..a353e27f83f5 100644
--- a/drivers/firmware/sysfb_simplefb.c
+++ b/drivers/firmware/sysfb_simplefb.c
@@ -57,8 +57,8 @@ __init bool sysfb_parse_mode(const struct screen_info *si,
 	return false;
 }
 
-__init int sysfb_create_simplefb(const struct screen_info *si,
-				 const struct simplefb_platform_data *mode)
+__init struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
+						     const struct simplefb_platform_data *mode)
 {
 	struct platform_device *pd;
 	struct resource res;
@@ -76,7 +76,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 		base |= (u64)si->ext_lfb_base << 32;
 	if (!base || (u64)(resource_size_t)base != base) {
 		printk(KERN_DEBUG "sysfb: inaccessible VRAM base\n");
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 	}
 
 	/*
@@ -93,7 +93,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 	length = mode->height * mode->stride;
 	if (length > size) {
 		printk(KERN_WARNING "sysfb: VRAM smaller than advertised\n");
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 	}
 	length = PAGE_ALIGN(length);
 
@@ -104,11 +104,11 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 	res.start = base;
 	res.end = res.start + length - 1;
 	if (res.end <= res.start)
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 
 	pd = platform_device_alloc("simple-framebuffer", 0);
 	if (!pd)
-		return -ENOMEM;
+		return ERR_PTR(-ENOMEM);
 
 	sysfb_apply_efi_quirks(pd);
 
@@ -124,10 +124,10 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 	if (ret)
 		goto err_put_device;
 
-	return 0;
+	return pd;
 
 err_put_device:
 	platform_device_put(pd);
 
-	return ret;
+	return ERR_PTR(ret);
 }
diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
index b0dcfa26d07b..708152e9037b 100644
--- a/include/linux/sysfb.h
+++ b/include/linux/sysfb.h
@@ -72,8 +72,8 @@ static inline void sysfb_apply_efi_quirks(struct platform_device *pd)
 
 bool sysfb_parse_mode(const struct screen_info *si,
 		      struct simplefb_platform_data *mode);
-int sysfb_create_simplefb(const struct screen_info *si,
-			  const struct simplefb_platform_data *mode);
+struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
+					      const struct simplefb_platform_data *mode);
 
 #else /* CONFIG_SYSFB_SIMPLE */
 
@@ -83,10 +83,10 @@ static inline bool sysfb_parse_mode(const struct screen_info *si,
 	return false;
 }
 
-static inline int sysfb_create_simplefb(const struct screen_info *si,
-					 const struct simplefb_platform_data *mode)
+static inline struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
+							    const struct simplefb_platform_data *mode)
 {
-	return -EINVAL;
+	return ERR_PTR(-EINVAL);
 }
 
 #endif /* CONFIG_SYSFB_SIMPLE */
-- 
2.35.1

[PATCH v3 1/5] firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer

[Javier Martinez Canillas]

This function just returned 0 on success or an errno code on error, but it
could be useful for sysfb_init() callers to have a pointer to the device.

Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v2)

Changes in v2:
- Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).

 drivers/firmware/sysfb.c          |  4 ++--
 drivers/firmware/sysfb_simplefb.c | 16 ++++++++--------
 include/linux/sysfb.h             | 10 +++++-----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
index 2bfbb05f7d89..b032f40a92de 100644
--- a/drivers/firmware/sysfb.c
+++ b/drivers/firmware/sysfb.c
@@ -46,8 +46,8 @@ static __init int sysfb_init(void)
 	/* try to create a simple-framebuffer device */
 	compatible = sysfb_parse_mode(si, &mode);
 	if (compatible) {
-		ret = sysfb_create_simplefb(si, &mode);
-		if (!ret)
+		pd = sysfb_create_simplefb(si, &mode);
+		if (!IS_ERR(pd))
 			return 0;
 	}
 
diff --git a/drivers/firmware/sysfb_simplefb.c b/drivers/firmware/sysfb_simplefb.c
index bda8712bfd8c..a353e27f83f5 100644
--- a/drivers/firmware/sysfb_simplefb.c
+++ b/drivers/firmware/sysfb_simplefb.c
@@ -57,8 +57,8 @@ __init bool sysfb_parse_mode(const struct screen_info *si,
 	return false;
 }
 
-__init int sysfb_create_simplefb(const struct screen_info *si,
-				 const struct simplefb_platform_data *mode)
+__init struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
+						     const struct simplefb_platform_data *mode)
 {
 	struct platform_device *pd;
 	struct resource res;
@@ -76,7 +76,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 		base |= (u64)si->ext_lfb_base << 32;
 	if (!base || (u64)(resource_size_t)base != base) {
 		printk(KERN_DEBUG "sysfb: inaccessible VRAM base\n");
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 	}
 
 	/*
@@ -93,7 +93,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 	length = mode->height * mode->stride;
 	if (length > size) {
 		printk(KERN_WARNING "sysfb: VRAM smaller than advertised\n");
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 	}
 	length = PAGE_ALIGN(length);
 
@@ -104,11 +104,11 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 	res.start = base;
 	res.end = res.start + length - 1;
 	if (res.end <= res.start)
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 
 	pd = platform_device_alloc("simple-framebuffer", 0);
 	if (!pd)
-		return -ENOMEM;
+		return ERR_PTR(-ENOMEM);
 
 	sysfb_apply_efi_quirks(pd);
 
@@ -124,10 +124,10 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
 	if (ret)
 		goto err_put_device;
 
-	return 0;
+	return pd;
 
 err_put_device:
 	platform_device_put(pd);
 
-	return ret;
+	return ERR_PTR(ret);
 }
diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
index b0dcfa26d07b..708152e9037b 100644
--- a/include/linux/sysfb.h
+++ b/include/linux/sysfb.h
@@ -72,8 +72,8 @@ static inline void sysfb_apply_efi_quirks(struct platform_device *pd)
 
 bool sysfb_parse_mode(const struct screen_info *si,
 		      struct simplefb_platform_data *mode);
-int sysfb_create_simplefb(const struct screen_info *si,
-			  const struct simplefb_platform_data *mode);
+struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
+					      const struct simplefb_platform_data *mode);
 
 #else /* CONFIG_SYSFB_SIMPLE */
 
@@ -83,10 +83,10 @@ static inline bool sysfb_parse_mode(const struct screen_info *si,
 	return false;
 }
 
-static inline int sysfb_create_simplefb(const struct screen_info *si,
-					 const struct simplefb_platform_data *mode)
+static inline struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
+							    const struct simplefb_platform_data *mode)
 {
-	return -EINVAL;
+	return ERR_PTR(-EINVAL);
 }
 
 #endif /* CONFIG_SYSFB_SIMPLE */
-- 
2.35.1

[PATCH v3 2/5] firmware: sysfb: Add helpers to unregister a pdev and disable registration

[Javier Martinez Canillas]

These can be used by subsystems to unregister a platform device registered
by sysfb and also to disable future platform device registration in sysfb.

Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v2)

Changes in v2:
- Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).

 .../driver-api/firmware/other_interfaces.rst  |  6 ++
 drivers/firmware/sysfb.c                      | 73 +++++++++++++++++--
 include/linux/sysfb.h                         | 19 +++++
 3 files changed, 92 insertions(+), 6 deletions(-)

diff --git a/Documentation/driver-api/firmware/other_interfaces.rst b/Documentation/driver-api/firmware/other_interfaces.rst
index b81794e0cfbb..06ac89adaafb 100644
--- a/Documentation/driver-api/firmware/other_interfaces.rst
+++ b/Documentation/driver-api/firmware/other_interfaces.rst
@@ -13,6 +13,12 @@ EDD Interfaces
 .. kernel-doc:: drivers/firmware/edd.c
    :internal:
 
+Generic System Framebuffers Interface
+-------------------------------------
+
+.. kernel-doc:: drivers/firmware/sysfb.c
+   :export:
+
 Intel Stratix10 SoC Service Layer
 ---------------------------------
 Some features of the Intel Stratix10 SoC require a level of privilege
diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
index b032f40a92de..a50d2858ce4d 100644
--- a/drivers/firmware/sysfb.c
+++ b/drivers/firmware/sysfb.c
@@ -34,21 +34,78 @@
 #include <linux/screen_info.h>
 #include <linux/sysfb.h>
 
+static struct platform_device *pd;
+static DEFINE_MUTEX(load_lock);
+static bool disabled;
+
+/**
+ * sysfb_disable() - disable the Generic System Framebuffers support
+ *
+ * This disables the registration of system framebuffer devices that match the
+ * generic drivers that make use of the system framebuffer set up by firmware.
+ *
+ * Context: The function can sleep. A @load_lock mutex is acquired to serialize
+ *          against sysfb_init(), that registers a system framebuffer device and
+ *          sysfb_try_unregister(), that tries to unregister framebuffer devices.
+ */
+void sysfb_disable(void)
+{
+	mutex_lock(&load_lock);
+	disabled = true;
+	mutex_unlock(&load_lock);
+}
+EXPORT_SYMBOL_GPL(sysfb_disable);
+
+/**
+ * sysfb_try_unregister() - attempt to unregister a system framebuffer device
+ * @dev: device to unregister
+ *
+ * This tries to unregister a system framebuffer device if this was registered
+ * by the Generic System Framebuffers. The device will only be unregistered if
+ * it was registered by sysfb_init(), otherwise it will not be unregistered.
+ *
+ * Context: The function can sleep. a @load_lock mutex is acquired to serialize
+ *          against sysfb_init(), that registers a simple framebuffer device and
+ *          sysfb_disable(), that disables the Generic System Framebuffers support.
+ *
+ * Return:
+ * * true          - the device was unregistered successfully
+ * * false         - the device was not unregistered
+ */
+bool sysfb_try_unregister(struct device *dev)
+{
+	bool ret = true;
+
+	mutex_lock(&load_lock);
+	if (!pd || pd != to_platform_device(dev))
+		return false;
+
+	platform_device_unregister(to_platform_device(dev));
+	pd = NULL;
+	mutex_unlock(&load_lock);
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(sysfb_try_unregister);
+
 static __init int sysfb_init(void)
 {
 	struct screen_info *si = &screen_info;
 	struct simplefb_platform_data mode;
-	struct platform_device *pd;
 	const char *name;
 	bool compatible;
-	int ret;
+	int ret = 0;
+
+	mutex_lock(&load_lock);
+	if (disabled)
+		goto unlock_mutex;
 
 	/* try to create a simple-framebuffer device */
 	compatible = sysfb_parse_mode(si, &mode);
 	if (compatible) {
 		pd = sysfb_create_simplefb(si, &mode);
 		if (!IS_ERR(pd))
-			return 0;
+			goto unlock_mutex;
 	}
 
 	/* if the FB is incompatible, create a legacy framebuffer device */
@@ -60,8 +117,10 @@ static __init int sysfb_init(void)
 		name = "platform-framebuffer";
 
 	pd = platform_device_alloc(name, 0);
-	if (!pd)
-		return -ENOMEM;
+	if (!pd) {
+		ret = -ENOMEM;
+		goto unlock_mutex;
+	}
 
 	sysfb_apply_efi_quirks(pd);
 
@@ -73,9 +132,11 @@ static __init int sysfb_init(void)
 	if (ret)
 		goto err;
 
-	return 0;
+	goto unlock_mutex;
 err:
 	platform_device_put(pd);
+unlock_mutex:
+	mutex_unlock(&load_lock);
 	return ret;
 }
 
diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
index 708152e9037b..e8c0313fac8f 100644
--- a/include/linux/sysfb.h
+++ b/include/linux/sysfb.h
@@ -55,6 +55,25 @@ struct efifb_dmi_info {
 	int flags;
 };
 
+#ifdef CONFIG_SYSFB
+
+void sysfb_disable(void);
+bool sysfb_try_unregister(struct device *dev);
+
+#else /* CONFIG_SYSFB */
+
+static inline void sysfb_disable(void)
+{
+
+}
+
+static inline bool sysfb_try_unregister(struct device *dev)
+{
+	return false;
+}
+
+#endif /* CONFIG_SYSFB */
+
 #ifdef CONFIG_EFI
 
 extern struct efifb_dmi_info efifb_dmi_list[];
-- 
2.35.1

[PATCH v3 2/5] firmware: sysfb: Add helpers to unregister a pdev and disable registration

[Javier Martinez Canillas]

These can be used by subsystems to unregister a platform device registered
by sysfb and also to disable future platform device registration in sysfb.

Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v2)

Changes in v2:
- Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).

 .../driver-api/firmware/other_interfaces.rst  |  6 ++
 drivers/firmware/sysfb.c                      | 73 +++++++++++++++++--
 include/linux/sysfb.h                         | 19 +++++
 3 files changed, 92 insertions(+), 6 deletions(-)

diff --git a/Documentation/driver-api/firmware/other_interfaces.rst b/Documentation/driver-api/firmware/other_interfaces.rst
index b81794e0cfbb..06ac89adaafb 100644
--- a/Documentation/driver-api/firmware/other_interfaces.rst
+++ b/Documentation/driver-api/firmware/other_interfaces.rst
@@ -13,6 +13,12 @@ EDD Interfaces
 .. kernel-doc:: drivers/firmware/edd.c
    :internal:
 
+Generic System Framebuffers Interface
+-------------------------------------
+
+.. kernel-doc:: drivers/firmware/sysfb.c
+   :export:
+
 Intel Stratix10 SoC Service Layer
 ---------------------------------
 Some features of the Intel Stratix10 SoC require a level of privilege
diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
index b032f40a92de..a50d2858ce4d 100644
--- a/drivers/firmware/sysfb.c
+++ b/drivers/firmware/sysfb.c
@@ -34,21 +34,78 @@
 #include <linux/screen_info.h>
 #include <linux/sysfb.h>
 
+static struct platform_device *pd;
+static DEFINE_MUTEX(load_lock);
+static bool disabled;
+
+/**
+ * sysfb_disable() - disable the Generic System Framebuffers support
+ *
+ * This disables the registration of system framebuffer devices that match the
+ * generic drivers that make use of the system framebuffer set up by firmware.
+ *
+ * Context: The function can sleep. A @load_lock mutex is acquired to serialize
+ *          against sysfb_init(), that registers a system framebuffer device and
+ *          sysfb_try_unregister(), that tries to unregister framebuffer devices.
+ */
+void sysfb_disable(void)
+{
+	mutex_lock(&load_lock);
+	disabled = true;
+	mutex_unlock(&load_lock);
+}
+EXPORT_SYMBOL_GPL(sysfb_disable);
+
+/**
+ * sysfb_try_unregister() - attempt to unregister a system framebuffer device
+ * @dev: device to unregister
+ *
+ * This tries to unregister a system framebuffer device if this was registered
+ * by the Generic System Framebuffers. The device will only be unregistered if
+ * it was registered by sysfb_init(), otherwise it will not be unregistered.
+ *
+ * Context: The function can sleep. a @load_lock mutex is acquired to serialize
+ *          against sysfb_init(), that registers a simple framebuffer device and
+ *          sysfb_disable(), that disables the Generic System Framebuffers support.
+ *
+ * Return:
+ * * true          - the device was unregistered successfully
+ * * false         - the device was not unregistered
+ */
+bool sysfb_try_unregister(struct device *dev)
+{
+	bool ret = true;
+
+	mutex_lock(&load_lock);
+	if (!pd || pd != to_platform_device(dev))
+		return false;
+
+	platform_device_unregister(to_platform_device(dev));
+	pd = NULL;
+	mutex_unlock(&load_lock);
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(sysfb_try_unregister);
+
 static __init int sysfb_init(void)
 {
 	struct screen_info *si = &screen_info;
 	struct simplefb_platform_data mode;
-	struct platform_device *pd;
 	const char *name;
 	bool compatible;
-	int ret;
+	int ret = 0;
+
+	mutex_lock(&load_lock);
+	if (disabled)
+		goto unlock_mutex;
 
 	/* try to create a simple-framebuffer device */
 	compatible = sysfb_parse_mode(si, &mode);
 	if (compatible) {
 		pd = sysfb_create_simplefb(si, &mode);
 		if (!IS_ERR(pd))
-			return 0;
+			goto unlock_mutex;
 	}
 
 	/* if the FB is incompatible, create a legacy framebuffer device */
@@ -60,8 +117,10 @@ static __init int sysfb_init(void)
 		name = "platform-framebuffer";
 
 	pd = platform_device_alloc(name, 0);
-	if (!pd)
-		return -ENOMEM;
+	if (!pd) {
+		ret = -ENOMEM;
+		goto unlock_mutex;
+	}
 
 	sysfb_apply_efi_quirks(pd);
 
@@ -73,9 +132,11 @@ static __init int sysfb_init(void)
 	if (ret)
 		goto err;
 
-	return 0;
+	goto unlock_mutex;
 err:
 	platform_device_put(pd);
+unlock_mutex:
+	mutex_unlock(&load_lock);
 	return ret;
 }
 
diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
index 708152e9037b..e8c0313fac8f 100644
--- a/include/linux/sysfb.h
+++ b/include/linux/sysfb.h
@@ -55,6 +55,25 @@ struct efifb_dmi_info {
 	int flags;
 };
 
+#ifdef CONFIG_SYSFB
+
+void sysfb_disable(void);
+bool sysfb_try_unregister(struct device *dev);
+
+#else /* CONFIG_SYSFB */
+
+static inline void sysfb_disable(void)
+{
+
+}
+
+static inline bool sysfb_try_unregister(struct device *dev)
+{
+	return false;
+}
+
+#endif /* CONFIG_SYSFB */
+
 #ifdef CONFIG_EFI
 
 extern struct efifb_dmi_info efifb_dmi_list[];
-- 
2.35.1

[PATCH v3 3/5] fbdev: Restart conflicting fb removal loop when unregistering devices

[Javier Martinez Canillas]

Drivers that want to remove registered conflicting framebuffers prior to
register their own framebuffer, calls remove_conflicting_framebuffers().

This function takes the registration_lock mutex, to prevent a races when
drivers register framebuffer devices. But if a conflicting framebuffer
device is found, the underlaying platform device is unregistered and this
will lead to the platform driver .remove callback to be called, which in
turn will call to the unregister_framebuffer() that takes the same lock.

To prevent this, a struct fb_info.forced_out field was used as indication
to unregister_framebuffer() whether the mutex has to be grabbed or not.

A cleaner solution is to drop the lock before platform_device_unregister()
so unregister_framebuffer() can take it when called from the fbdev driver,
and just grab the lock again after the device has been registered and do
a removal loop restart.

Since the framebuffer devices will already be removed, the loop would just
finish when no more conflicting framebuffers are found.

Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v1)

 drivers/video/fbdev/core/fbmem.c | 22 +++++++++++++++-------
 include/linux/fb.h               |  1 -
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
index 84427470367b..0bb459258df3 100644
--- a/drivers/video/fbdev/core/fbmem.c
+++ b/drivers/video/fbdev/core/fbmem.c
@@ -1553,6 +1553,7 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
 {
 	int i;
 
+restart_removal:
 	/* check all firmware fbs and kick off if the base addr overlaps */
 	for_each_registered_fb(i) {
 		struct apertures_struct *gen_aper;
@@ -1585,12 +1586,23 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
 				pr_warn("fb%d: no device set\n", i);
 				do_unregister_framebuffer(registered_fb[i]);
 			} else if (dev_is_platform(device)) {
-				registered_fb[i]->forced_out = true;
+				/*
+				 * Drop the lock because if the device is unregistered, its
+				 * driver will call to unregister_framebuffer(), that takes
+				 * this lock.
+				 */
+				mutex_unlock(&registration_lock);
 				platform_device_unregister(to_platform_device(device));
+				mutex_lock(&registration_lock);
 			} else {
 				pr_warn("fb%d: cannot remove device\n", i);
 				do_unregister_framebuffer(registered_fb[i]);
 			}
+			/*
+			 * Restart the removal loop now that the device has been
+			 * unregistered and its associated framebuffer gone.
+			 */
+			goto restart_removal;
 		}
 	}
 }
@@ -1897,13 +1909,9 @@ EXPORT_SYMBOL(register_framebuffer);
 void
 unregister_framebuffer(struct fb_info *fb_info)
 {
-	bool forced_out = fb_info->forced_out;
-
-	if (!forced_out)
-		mutex_lock(&registration_lock);
+	mutex_lock(&registration_lock);
 	do_unregister_framebuffer(fb_info);
-	if (!forced_out)
-		mutex_unlock(&registration_lock);
+	mutex_unlock(&registration_lock);
 }
 EXPORT_SYMBOL(unregister_framebuffer);
 
diff --git a/include/linux/fb.h b/include/linux/fb.h
index f95da1af9ff6..b781bc721113 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -502,7 +502,6 @@ struct fb_info {
 	} *apertures;
 
 	bool skip_vt_switch; /* no VT switch on suspend/resume required */
-	bool forced_out; /* set when being removed by another driver */
 };
 
 static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
-- 
2.35.1

[PATCH v3 3/5] fbdev: Restart conflicting fb removal loop when unregistering devices

[Javier Martinez Canillas]

Drivers that want to remove registered conflicting framebuffers prior to
register their own framebuffer, calls remove_conflicting_framebuffers().

This function takes the registration_lock mutex, to prevent a races when
drivers register framebuffer devices. But if a conflicting framebuffer
device is found, the underlaying platform device is unregistered and this
will lead to the platform driver .remove callback to be called, which in
turn will call to the unregister_framebuffer() that takes the same lock.

To prevent this, a struct fb_info.forced_out field was used as indication
to unregister_framebuffer() whether the mutex has to be grabbed or not.

A cleaner solution is to drop the lock before platform_device_unregister()
so unregister_framebuffer() can take it when called from the fbdev driver,
and just grab the lock again after the device has been registered and do
a removal loop restart.

Since the framebuffer devices will already be removed, the loop would just
finish when no more conflicting framebuffers are found.

Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v1)

 drivers/video/fbdev/core/fbmem.c | 22 +++++++++++++++-------
 include/linux/fb.h               |  1 -
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
index 84427470367b..0bb459258df3 100644
--- a/drivers/video/fbdev/core/fbmem.c
+++ b/drivers/video/fbdev/core/fbmem.c
@@ -1553,6 +1553,7 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
 {
 	int i;
 
+restart_removal:
 	/* check all firmware fbs and kick off if the base addr overlaps */
 	for_each_registered_fb(i) {
 		struct apertures_struct *gen_aper;
@@ -1585,12 +1586,23 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
 				pr_warn("fb%d: no device set\n", i);
 				do_unregister_framebuffer(registered_fb[i]);
 			} else if (dev_is_platform(device)) {
-				registered_fb[i]->forced_out = true;
+				/*
+				 * Drop the lock because if the device is unregistered, its
+				 * driver will call to unregister_framebuffer(), that takes
+				 * this lock.
+				 */
+				mutex_unlock(&registration_lock);
 				platform_device_unregister(to_platform_device(device));
+				mutex_lock(&registration_lock);
 			} else {
 				pr_warn("fb%d: cannot remove device\n", i);
 				do_unregister_framebuffer(registered_fb[i]);
 			}
+			/*
+			 * Restart the removal loop now that the device has been
+			 * unregistered and its associated framebuffer gone.
+			 */
+			goto restart_removal;
 		}
 	}
 }
@@ -1897,13 +1909,9 @@ EXPORT_SYMBOL(register_framebuffer);
 void
 unregister_framebuffer(struct fb_info *fb_info)
 {
-	bool forced_out = fb_info->forced_out;
-
-	if (!forced_out)
-		mutex_lock(&registration_lock);
+	mutex_lock(&registration_lock);
 	do_unregister_framebuffer(fb_info);
-	if (!forced_out)
-		mutex_unlock(&registration_lock);
+	mutex_unlock(&registration_lock);
 }
 EXPORT_SYMBOL(unregister_framebuffer);
 
diff --git a/include/linux/fb.h b/include/linux/fb.h
index f95da1af9ff6..b781bc721113 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -502,7 +502,6 @@ struct fb_info {
 	} *apertures;
 
 	bool skip_vt_switch; /* no VT switch on suspend/resume required */
-	bool forced_out; /* set when being removed by another driver */
 };
 
 static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
-- 
2.35.1

[PATCH v3 4/5] fbdev: Fix some race conditions between fbmem and sysfb

[Javier Martinez Canillas]

The platform devices registered in sysfb match with a firmware-based fbdev
or DRM driver, that are used to have early graphics using framebuffers set
up by the system firmware.

Real DRM drivers later are probed and remove all conflicting framebuffers,
leading to these platform devices for generic drivers to be unregistered.

But the current solution has two issues that this patch fixes:

1) It is a layering violation for the fbdev core to unregister a device
   that was registered by sysfb.

   Instead, the sysfb_try_unregister() helper function can be called for
   sysfb to attempt unregistering the device if is the one registered.

2) The sysfb_init() function could be called after a DRM driver is probed
   and requested to unregister devices for drivers with a conflicting fb.

   To prevent this, disable any future sysfb platform device registration
   by calling sysfb_disable(), if a driver requested to remove conflicting
   framebuffers with remove_conflicting_framebuffers().

There are video drivers (e.g: vga16fb) that register their own device and
don't use the sysfb infrastructure for that, so an unregistration has to
be forced by fbmem if sysfb_try_unregister() fails to do the unregister.

Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v2)

Changes in v2:
- Explain in the commit message that fbmem has to unregister the device
  as fallback if a driver registered the device itself (Daniel Vetter).
- Also explain that fallback in a comment in the code (Daniel Vetter).
- Don't encode in fbmem the assumption that sysfb will always register
  platform devices (Daniel Vetter).
- Add a FIXME comment about drivers registering devices (Daniel Vetter).

 drivers/video/fbdev/core/fbmem.c | 42 ++++++++++++++++++++++++++++----
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
index 0bb459258df3..8098305879f8 100644
--- a/drivers/video/fbdev/core/fbmem.c
+++ b/drivers/video/fbdev/core/fbmem.c
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/major.h>
 #include <linux/slab.h>
+#include <linux/sysfb.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
 #include <linux/vt.h>
@@ -1585,18 +1586,38 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
 			if (!device) {
 				pr_warn("fb%d: no device set\n", i);
 				do_unregister_framebuffer(registered_fb[i]);
-			} else if (dev_is_platform(device)) {
+			} else {
 				/*
 				 * Drop the lock because if the device is unregistered, its
 				 * driver will call to unregister_framebuffer(), that takes
 				 * this lock.
 				 */
 				mutex_unlock(&registration_lock);
-				platform_device_unregister(to_platform_device(device));
+				/*
+				 * First attempt the device to be unregistered by sysfb.
+				 */
+				if (!sysfb_try_unregister(device)) {
+					if (dev_is_platform(device)) {
+						/*
+						 * FIXME: sysfb didn't register this device, is a platform
+						 * device registered by a video driver (e.g: vga16fb), so
+						 * force its unregistration here. A proper fix would be to
+						 * move all device registration to the sysfb infrastructure
+						 * or platform code.
+						 */
+						platform_device_unregister(to_platform_device(device));
+					} else {
+						/*
+						 * If is not a platform device, at least print a warning. A
+						 * fix would add to make the code that registered the device
+						 * to also unregister it.
+						 */
+						pr_warn("fb%d: cannot remove device\n", i);
+						/* call unregister_framebuffer() since the lock was dropped */
+						unregister_framebuffer(registered_fb[i]);
+					}
+				}
 				mutex_lock(&registration_lock);
-			} else {
-				pr_warn("fb%d: cannot remove device\n", i);
-				do_unregister_framebuffer(registered_fb[i]);
 			}
 			/*
 			 * Restart the removal loop now that the device has been
@@ -1762,6 +1783,17 @@ int remove_conflicting_framebuffers(struct apertures_struct *a,
 		do_free = true;
 	}
 
+	/*
+	 * If a driver asked to unregister a platform device registered by
+	 * sysfb, then can be assumed that this is a driver for a display
+	 * that is set up by the system firmware and has a generic driver.
+	 *
+	 * Drivers for devices that don't have a generic driver will never
+	 * ask for this, so let's assume that a real driver for the display
+	 * was already probed and prevent sysfb to register devices later.
+	 */
+	sysfb_disable();
+
 	mutex_lock(&registration_lock);
 	do_remove_conflicting_framebuffers(a, name, primary);
 	mutex_unlock(&registration_lock);
-- 
2.35.1

[PATCH v3 4/5] fbdev: Fix some race conditions between fbmem and sysfb

[Javier Martinez Canillas]

The platform devices registered in sysfb match with a firmware-based fbdev
or DRM driver, that are used to have early graphics using framebuffers set
up by the system firmware.

Real DRM drivers later are probed and remove all conflicting framebuffers,
leading to these platform devices for generic drivers to be unregistered.

But the current solution has two issues that this patch fixes:

1) It is a layering violation for the fbdev core to unregister a device
   that was registered by sysfb.

   Instead, the sysfb_try_unregister() helper function can be called for
   sysfb to attempt unregistering the device if is the one registered.

2) The sysfb_init() function could be called after a DRM driver is probed
   and requested to unregister devices for drivers with a conflicting fb.

   To prevent this, disable any future sysfb platform device registration
   by calling sysfb_disable(), if a driver requested to remove conflicting
   framebuffers with remove_conflicting_framebuffers().

There are video drivers (e.g: vga16fb) that register their own device and
don't use the sysfb infrastructure for that, so an unregistration has to
be forced by fbmem if sysfb_try_unregister() fails to do the unregister.

Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
---

(no changes since v2)

Changes in v2:
- Explain in the commit message that fbmem has to unregister the device
  as fallback if a driver registered the device itself (Daniel Vetter).
- Also explain that fallback in a comment in the code (Daniel Vetter).
- Don't encode in fbmem the assumption that sysfb will always register
  platform devices (Daniel Vetter).
- Add a FIXME comment about drivers registering devices (Daniel Vetter).

 drivers/video/fbdev/core/fbmem.c | 42 ++++++++++++++++++++++++++++----
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
index 0bb459258df3..8098305879f8 100644
--- a/drivers/video/fbdev/core/fbmem.c
+++ b/drivers/video/fbdev/core/fbmem.c
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/major.h>
 #include <linux/slab.h>
+#include <linux/sysfb.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
 #include <linux/vt.h>
@@ -1585,18 +1586,38 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
 			if (!device) {
 				pr_warn("fb%d: no device set\n", i);
 				do_unregister_framebuffer(registered_fb[i]);
-			} else if (dev_is_platform(device)) {
+			} else {
 				/*
 				 * Drop the lock because if the device is unregistered, its
 				 * driver will call to unregister_framebuffer(), that takes
 				 * this lock.
 				 */
 				mutex_unlock(&registration_lock);
-				platform_device_unregister(to_platform_device(device));
+				/*
+				 * First attempt the device to be unregistered by sysfb.
+				 */
+				if (!sysfb_try_unregister(device)) {
+					if (dev_is_platform(device)) {
+						/*
+						 * FIXME: sysfb didn't register this device, is a platform
+						 * device registered by a video driver (e.g: vga16fb), so
+						 * force its unregistration here. A proper fix would be to
+						 * move all device registration to the sysfb infrastructure
+						 * or platform code.
+						 */
+						platform_device_unregister(to_platform_device(device));
+					} else {
+						/*
+						 * If is not a platform device, at least print a warning. A
+						 * fix would add to make the code that registered the device
+						 * to also unregister it.
+						 */
+						pr_warn("fb%d: cannot remove device\n", i);
+						/* call unregister_framebuffer() since the lock was dropped */
+						unregister_framebuffer(registered_fb[i]);
+					}
+				}
 				mutex_lock(&registration_lock);
-			} else {
-				pr_warn("fb%d: cannot remove device\n", i);
-				do_unregister_framebuffer(registered_fb[i]);
 			}
 			/*
 			 * Restart the removal loop now that the device has been
@@ -1762,6 +1783,17 @@ int remove_conflicting_framebuffers(struct apertures_struct *a,
 		do_free = true;
 	}
 
+	/*
+	 * If a driver asked to unregister a platform device registered by
+	 * sysfb, then can be assumed that this is a driver for a display
+	 * that is set up by the system firmware and has a generic driver.
+	 *
+	 * Drivers for devices that don't have a generic driver will never
+	 * ask for this, so let's assume that a real driver for the display
+	 * was already probed and prevent sysfb to register devices later.
+	 */
+	sysfb_disable();
+
 	mutex_lock(&registration_lock);
 	do_remove_conflicting_framebuffers(a, name, primary);
 	mutex_unlock(&registration_lock);
-- 
2.35.1

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Greg Kroah-Hartman]

On Wed, Apr 20, 2022 at 10:52:58AM +0200, Javier Martinez Canillas wrote:
> Hello,
> 
> The patches in this series are mostly changes suggested by Daniel Vetter
> to fix some race conditions that exists between the fbdev core (fbmem)
> and sysfb with regard to device registration and removal.
> 
> For example, it is currently possible for sysfb to register a platform
> device after a real DRM driver was registered and requested to remove the
> conflicting framebuffers.
> 
> A symptom of this issue, was worked around with by commit fb561bf9abde
> ("fbdev: Prevent probing generic drivers if a FB is already registered")
> but that's really a hack and should be reverted.
> 
> This series attempt to fix it more properly and revert the mentioned hack.
> That will also unblock a pending patch to not make the num_registered_fb
> variable visible to drivers anymore, since that's internal to fbdev core.
> 
> Patch #1 is just a trivial preparatory change.
> 
> Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
> to use them.
> 
> Patch #3 changes how is dealt with conflicting framebuffers unregistering,
> rather than having a variable to determine if a lock should be take, it
> just drops the lock before unregistering the platform device.
> 
> Patch #4 fixes the mentioned race conditions and finally patch #5 is the
> revert patch that was posted by Daniel before but he dropped from his set.
> 
> The patches were tested on a rpi4 using different video configurations:
> (simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
> and simpledrm builtin with vc4 built as a module).
> 
> Best regards,
> Javier

Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Greg Kroah-Hartman]

On Wed, Apr 20, 2022 at 10:52:58AM +0200, Javier Martinez Canillas wrote:
> Hello,
> 
> The patches in this series are mostly changes suggested by Daniel Vetter
> to fix some race conditions that exists between the fbdev core (fbmem)
> and sysfb with regard to device registration and removal.
> 
> For example, it is currently possible for sysfb to register a platform
> device after a real DRM driver was registered and requested to remove the
> conflicting framebuffers.
> 
> A symptom of this issue, was worked around with by commit fb561bf9abde
> ("fbdev: Prevent probing generic drivers if a FB is already registered")
> but that's really a hack and should be reverted.
> 
> This series attempt to fix it more properly and revert the mentioned hack.
> That will also unblock a pending patch to not make the num_registered_fb
> variable visible to drivers anymore, since that's internal to fbdev core.
> 
> Patch #1 is just a trivial preparatory change.
> 
> Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
> to use them.
> 
> Patch #3 changes how is dealt with conflicting framebuffers unregistering,
> rather than having a variable to determine if a lock should be take, it
> just drops the lock before unregistering the platform device.
> 
> Patch #4 fixes the mentioned race conditions and finally patch #5 is the
> revert patch that was posted by Daniel before but he dropped from his set.
> 
> The patches were tested on a rpi4 using different video configurations:
> (simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
> and simpledrm builtin with vc4 built as a module).
> 
> Best regards,
> Javier

Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Re: [PATCH v3 1/5] firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 4662 bytes --]



Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
> This function just returned 0 on success or an errno code on error, but it
> could be useful for sysfb_init() callers to have a pointer to the device.
> 
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>

Reviewed-by: Thomas Zimmermann <tzimmermann@suse.de>

> ---
> 
> (no changes since v2)
> 
> Changes in v2:
> - Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).
> 
>   drivers/firmware/sysfb.c          |  4 ++--
>   drivers/firmware/sysfb_simplefb.c | 16 ++++++++--------
>   include/linux/sysfb.h             | 10 +++++-----
>   3 files changed, 15 insertions(+), 15 deletions(-)
> 
> diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
> index 2bfbb05f7d89..b032f40a92de 100644
> --- a/drivers/firmware/sysfb.c
> +++ b/drivers/firmware/sysfb.c
> @@ -46,8 +46,8 @@ static __init int sysfb_init(void)
>   	/* try to create a simple-framebuffer device */
>   	compatible = sysfb_parse_mode(si, &mode);
>   	if (compatible) {
> -		ret = sysfb_create_simplefb(si, &mode);
> -		if (!ret)
> +		pd = sysfb_create_simplefb(si, &mode);
> +		if (!IS_ERR(pd))
>   			return 0;
>   	}
>   
> diff --git a/drivers/firmware/sysfb_simplefb.c b/drivers/firmware/sysfb_simplefb.c
> index bda8712bfd8c..a353e27f83f5 100644
> --- a/drivers/firmware/sysfb_simplefb.c
> +++ b/drivers/firmware/sysfb_simplefb.c
> @@ -57,8 +57,8 @@ __init bool sysfb_parse_mode(const struct screen_info *si,
>   	return false;
>   }
>   
> -__init int sysfb_create_simplefb(const struct screen_info *si,
> -				 const struct simplefb_platform_data *mode)
> +__init struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
> +						     const struct simplefb_platform_data *mode)
>   {
>   	struct platform_device *pd;
>   	struct resource res;
> @@ -76,7 +76,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   		base |= (u64)si->ext_lfb_base << 32;
>   	if (!base || (u64)(resource_size_t)base != base) {
>   		printk(KERN_DEBUG "sysfb: inaccessible VRAM base\n");
> -		return -EINVAL;
> +		return ERR_PTR(-EINVAL);
>   	}
>   
>   	/*
> @@ -93,7 +93,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   	length = mode->height * mode->stride;
>   	if (length > size) {
>   		printk(KERN_WARNING "sysfb: VRAM smaller than advertised\n");
> -		return -EINVAL;
> +		return ERR_PTR(-EINVAL);
>   	}
>   	length = PAGE_ALIGN(length);
>   
> @@ -104,11 +104,11 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   	res.start = base;
>   	res.end = res.start + length - 1;
>   	if (res.end <= res.start)
> -		return -EINVAL;
> +		return ERR_PTR(-EINVAL);
>   
>   	pd = platform_device_alloc("simple-framebuffer", 0);
>   	if (!pd)
> -		return -ENOMEM;
> +		return ERR_PTR(-ENOMEM);
>   
>   	sysfb_apply_efi_quirks(pd);
>   
> @@ -124,10 +124,10 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   	if (ret)
>   		goto err_put_device;
>   
> -	return 0;
> +	return pd;
>   
>   err_put_device:
>   	platform_device_put(pd);
>   
> -	return ret;
> +	return ERR_PTR(ret);
>   }
> diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
> index b0dcfa26d07b..708152e9037b 100644
> --- a/include/linux/sysfb.h
> +++ b/include/linux/sysfb.h
> @@ -72,8 +72,8 @@ static inline void sysfb_apply_efi_quirks(struct platform_device *pd)
>   
>   bool sysfb_parse_mode(const struct screen_info *si,
>   		      struct simplefb_platform_data *mode);
> -int sysfb_create_simplefb(const struct screen_info *si,
> -			  const struct simplefb_platform_data *mode);
> +struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
> +					      const struct simplefb_platform_data *mode);
>   
>   #else /* CONFIG_SYSFB_SIMPLE */
>   
> @@ -83,10 +83,10 @@ static inline bool sysfb_parse_mode(const struct screen_info *si,
>   	return false;
>   }
>   
> -static inline int sysfb_create_simplefb(const struct screen_info *si,
> -					 const struct simplefb_platform_data *mode)
> +static inline struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
> +							    const struct simplefb_platform_data *mode)
>   {
> -	return -EINVAL;
> +	return ERR_PTR(-EINVAL);
>   }
>   
>   #endif /* CONFIG_SYSFB_SIMPLE */

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 1/5] firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 4662 bytes --]



Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
> This function just returned 0 on success or an errno code on error, but it
> could be useful for sysfb_init() callers to have a pointer to the device.
> 
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>

Reviewed-by: Thomas Zimmermann <tzimmermann@suse.de>

> ---
> 
> (no changes since v2)
> 
> Changes in v2:
> - Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).
> 
>   drivers/firmware/sysfb.c          |  4 ++--
>   drivers/firmware/sysfb_simplefb.c | 16 ++++++++--------
>   include/linux/sysfb.h             | 10 +++++-----
>   3 files changed, 15 insertions(+), 15 deletions(-)
> 
> diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
> index 2bfbb05f7d89..b032f40a92de 100644
> --- a/drivers/firmware/sysfb.c
> +++ b/drivers/firmware/sysfb.c
> @@ -46,8 +46,8 @@ static __init int sysfb_init(void)
>   	/* try to create a simple-framebuffer device */
>   	compatible = sysfb_parse_mode(si, &mode);
>   	if (compatible) {
> -		ret = sysfb_create_simplefb(si, &mode);
> -		if (!ret)
> +		pd = sysfb_create_simplefb(si, &mode);
> +		if (!IS_ERR(pd))
>   			return 0;
>   	}
>   
> diff --git a/drivers/firmware/sysfb_simplefb.c b/drivers/firmware/sysfb_simplefb.c
> index bda8712bfd8c..a353e27f83f5 100644
> --- a/drivers/firmware/sysfb_simplefb.c
> +++ b/drivers/firmware/sysfb_simplefb.c
> @@ -57,8 +57,8 @@ __init bool sysfb_parse_mode(const struct screen_info *si,
>   	return false;
>   }
>   
> -__init int sysfb_create_simplefb(const struct screen_info *si,
> -				 const struct simplefb_platform_data *mode)
> +__init struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
> +						     const struct simplefb_platform_data *mode)
>   {
>   	struct platform_device *pd;
>   	struct resource res;
> @@ -76,7 +76,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   		base |= (u64)si->ext_lfb_base << 32;
>   	if (!base || (u64)(resource_size_t)base != base) {
>   		printk(KERN_DEBUG "sysfb: inaccessible VRAM base\n");
> -		return -EINVAL;
> +		return ERR_PTR(-EINVAL);
>   	}
>   
>   	/*
> @@ -93,7 +93,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   	length = mode->height * mode->stride;
>   	if (length > size) {
>   		printk(KERN_WARNING "sysfb: VRAM smaller than advertised\n");
> -		return -EINVAL;
> +		return ERR_PTR(-EINVAL);
>   	}
>   	length = PAGE_ALIGN(length);
>   
> @@ -104,11 +104,11 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   	res.start = base;
>   	res.end = res.start + length - 1;
>   	if (res.end <= res.start)
> -		return -EINVAL;
> +		return ERR_PTR(-EINVAL);
>   
>   	pd = platform_device_alloc("simple-framebuffer", 0);
>   	if (!pd)
> -		return -ENOMEM;
> +		return ERR_PTR(-ENOMEM);
>   
>   	sysfb_apply_efi_quirks(pd);
>   
> @@ -124,10 +124,10 @@ __init int sysfb_create_simplefb(const struct screen_info *si,
>   	if (ret)
>   		goto err_put_device;
>   
> -	return 0;
> +	return pd;
>   
>   err_put_device:
>   	platform_device_put(pd);
>   
> -	return ret;
> +	return ERR_PTR(ret);
>   }
> diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
> index b0dcfa26d07b..708152e9037b 100644
> --- a/include/linux/sysfb.h
> +++ b/include/linux/sysfb.h
> @@ -72,8 +72,8 @@ static inline void sysfb_apply_efi_quirks(struct platform_device *pd)
>   
>   bool sysfb_parse_mode(const struct screen_info *si,
>   		      struct simplefb_platform_data *mode);
> -int sysfb_create_simplefb(const struct screen_info *si,
> -			  const struct simplefb_platform_data *mode);
> +struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
> +					      const struct simplefb_platform_data *mode);
>   
>   #else /* CONFIG_SYSFB_SIMPLE */
>   
> @@ -83,10 +83,10 @@ static inline bool sysfb_parse_mode(const struct screen_info *si,
>   	return false;
>   }
>   
> -static inline int sysfb_create_simplefb(const struct screen_info *si,
> -					 const struct simplefb_platform_data *mode)
> +static inline struct platform_device *sysfb_create_simplefb(const struct screen_info *si,
> +							    const struct simplefb_platform_data *mode)
>   {
> -	return -EINVAL;
> +	return ERR_PTR(-EINVAL);
>   }
>   
>   #endif /* CONFIG_SYSFB_SIMPLE */

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 2/5] firmware: sysfb: Add helpers to unregister a pdev and disable registration

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 6247 bytes --]

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
> These can be used by subsystems to unregister a platform device registered
> by sysfb and also to disable future platform device registration in sysfb.
> 
> Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> ---
> 
> (no changes since v2)
> 
> Changes in v2:
> - Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).
> 
>   .../driver-api/firmware/other_interfaces.rst  |  6 ++
>   drivers/firmware/sysfb.c                      | 73 +++++++++++++++++--
>   include/linux/sysfb.h                         | 19 +++++
>   3 files changed, 92 insertions(+), 6 deletions(-)
> 
> diff --git a/Documentation/driver-api/firmware/other_interfaces.rst b/Documentation/driver-api/firmware/other_interfaces.rst
> index b81794e0cfbb..06ac89adaafb 100644
> --- a/Documentation/driver-api/firmware/other_interfaces.rst
> +++ b/Documentation/driver-api/firmware/other_interfaces.rst
> @@ -13,6 +13,12 @@ EDD Interfaces
>   .. kernel-doc:: drivers/firmware/edd.c
>      :internal:
>   
> +Generic System Framebuffers Interface
> +-------------------------------------
> +
> +.. kernel-doc:: drivers/firmware/sysfb.c
> +   :export:
> +
>   Intel Stratix10 SoC Service Layer
>   ---------------------------------
>   Some features of the Intel Stratix10 SoC require a level of privilege
> diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
> index b032f40a92de..a50d2858ce4d 100644
> --- a/drivers/firmware/sysfb.c
> +++ b/drivers/firmware/sysfb.c
> @@ -34,21 +34,78 @@
>   #include <linux/screen_info.h>
>   #include <linux/sysfb.h>
>   
> +static struct platform_device *pd;

You could have multiple instances of simple-framebuffer because you 
don't know what the firmware set up. It originated from DT and EFI/VESA 
is really just an afterthought. If there is more than 1 instance, your 
entire unregistering breaks down.

(I've been told that such multi-output cases exist in the context of OF 
framebuffers. Something similar could exist for simple-frambuffer as well.)

Best regards
Thomas

> +static DEFINE_MUTEX(load_lock);
> +static bool disabled;
> +
> +/**
> + * sysfb_disable() - disable the Generic System Framebuffers support
> + *
> + * This disables the registration of system framebuffer devices that match the
> + * generic drivers that make use of the system framebuffer set up by firmware.
> + *
> + * Context: The function can sleep. A @load_lock mutex is acquired to serialize
> + *          against sysfb_init(), that registers a system framebuffer device and
> + *          sysfb_try_unregister(), that tries to unregister framebuffer devices.
> + */
> +void sysfb_disable(void)
> +{
> +	mutex_lock(&load_lock);
> +	disabled = true;
> +	mutex_unlock(&load_lock);
> +}
> +EXPORT_SYMBOL_GPL(sysfb_disable);
> +
> +/**
> + * sysfb_try_unregister() - attempt to unregister a system framebuffer device
> + * @dev: device to unregister
> + *
> + * This tries to unregister a system framebuffer device if this was registered
> + * by the Generic System Framebuffers. The device will only be unregistered if
> + * it was registered by sysfb_init(), otherwise it will not be unregistered.
> + *
> + * Context: The function can sleep. a @load_lock mutex is acquired to serialize
> + *          against sysfb_init(), that registers a simple framebuffer device and
> + *          sysfb_disable(), that disables the Generic System Framebuffers support.
> + *
> + * Return:
> + * * true          - the device was unregistered successfully
> + * * false         - the device was not unregistered
> + */
> +bool sysfb_try_unregister(struct device *dev)
> +{
> +	bool ret = true;
> +
> +	mutex_lock(&load_lock);
> +	if (!pd || pd != to_platform_device(dev))
> +		return false;
> +
> +	platform_device_unregister(to_platform_device(dev));
> +	pd = NULL;
> +	mutex_unlock(&load_lock);
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(sysfb_try_unregister);
> +
>   static __init int sysfb_init(void)
>   {
>   	struct screen_info *si = &screen_info;
>   	struct simplefb_platform_data mode;
> -	struct platform_device *pd;
>   	const char *name;
>   	bool compatible;
> -	int ret;
> +	int ret = 0;
> +
> +	mutex_lock(&load_lock);
> +	if (disabled)
> +		goto unlock_mutex;
>   
>   	/* try to create a simple-framebuffer device */
>   	compatible = sysfb_parse_mode(si, &mode);
>   	if (compatible) {
>   		pd = sysfb_create_simplefb(si, &mode);
>   		if (!IS_ERR(pd))
> -			return 0;
> +			goto unlock_mutex;
>   	}
>   
>   	/* if the FB is incompatible, create a legacy framebuffer device */
> @@ -60,8 +117,10 @@ static __init int sysfb_init(void)
>   		name = "platform-framebuffer";
>   
>   	pd = platform_device_alloc(name, 0);
> -	if (!pd)
> -		return -ENOMEM;
> +	if (!pd) {
> +		ret = -ENOMEM;
> +		goto unlock_mutex;
> +	}
>   
>   	sysfb_apply_efi_quirks(pd);
>   
> @@ -73,9 +132,11 @@ static __init int sysfb_init(void)
>   	if (ret)
>   		goto err;
>   
> -	return 0;
> +	goto unlock_mutex;
>   err:
>   	platform_device_put(pd);
> +unlock_mutex:
> +	mutex_unlock(&load_lock);
>   	return ret;
>   }
>   
> diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
> index 708152e9037b..e8c0313fac8f 100644
> --- a/include/linux/sysfb.h
> +++ b/include/linux/sysfb.h
> @@ -55,6 +55,25 @@ struct efifb_dmi_info {
>   	int flags;
>   };
>   
> +#ifdef CONFIG_SYSFB
> +
> +void sysfb_disable(void);
> +bool sysfb_try_unregister(struct device *dev);
> +
> +#else /* CONFIG_SYSFB */
> +
> +static inline void sysfb_disable(void)
> +{
> +
> +}
> +
> +static inline bool sysfb_try_unregister(struct device *dev)
> +{
> +	return false;
> +}
> +
> +#endif /* CONFIG_SYSFB */
> +
>   #ifdef CONFIG_EFI
>   
>   extern struct efifb_dmi_info efifb_dmi_list[];

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 2/5] firmware: sysfb: Add helpers to unregister a pdev and disable registration

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 6247 bytes --]

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
> These can be used by subsystems to unregister a platform device registered
> by sysfb and also to disable future platform device registration in sysfb.
> 
> Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> ---
> 
> (no changes since v2)
> 
> Changes in v2:
> - Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).
> 
>   .../driver-api/firmware/other_interfaces.rst  |  6 ++
>   drivers/firmware/sysfb.c                      | 73 +++++++++++++++++--
>   include/linux/sysfb.h                         | 19 +++++
>   3 files changed, 92 insertions(+), 6 deletions(-)
> 
> diff --git a/Documentation/driver-api/firmware/other_interfaces.rst b/Documentation/driver-api/firmware/other_interfaces.rst
> index b81794e0cfbb..06ac89adaafb 100644
> --- a/Documentation/driver-api/firmware/other_interfaces.rst
> +++ b/Documentation/driver-api/firmware/other_interfaces.rst
> @@ -13,6 +13,12 @@ EDD Interfaces
>   .. kernel-doc:: drivers/firmware/edd.c
>      :internal:
>   
> +Generic System Framebuffers Interface
> +-------------------------------------
> +
> +.. kernel-doc:: drivers/firmware/sysfb.c
> +   :export:
> +
>   Intel Stratix10 SoC Service Layer
>   ---------------------------------
>   Some features of the Intel Stratix10 SoC require a level of privilege
> diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c
> index b032f40a92de..a50d2858ce4d 100644
> --- a/drivers/firmware/sysfb.c
> +++ b/drivers/firmware/sysfb.c
> @@ -34,21 +34,78 @@
>   #include <linux/screen_info.h>
>   #include <linux/sysfb.h>
>   
> +static struct platform_device *pd;

You could have multiple instances of simple-framebuffer because you 
don't know what the firmware set up. It originated from DT and EFI/VESA 
is really just an afterthought. If there is more than 1 instance, your 
entire unregistering breaks down.

(I've been told that such multi-output cases exist in the context of OF 
framebuffers. Something similar could exist for simple-frambuffer as well.)

Best regards
Thomas

> +static DEFINE_MUTEX(load_lock);
> +static bool disabled;
> +
> +/**
> + * sysfb_disable() - disable the Generic System Framebuffers support
> + *
> + * This disables the registration of system framebuffer devices that match the
> + * generic drivers that make use of the system framebuffer set up by firmware.
> + *
> + * Context: The function can sleep. A @load_lock mutex is acquired to serialize
> + *          against sysfb_init(), that registers a system framebuffer device and
> + *          sysfb_try_unregister(), that tries to unregister framebuffer devices.
> + */
> +void sysfb_disable(void)
> +{
> +	mutex_lock(&load_lock);
> +	disabled = true;
> +	mutex_unlock(&load_lock);
> +}
> +EXPORT_SYMBOL_GPL(sysfb_disable);
> +
> +/**
> + * sysfb_try_unregister() - attempt to unregister a system framebuffer device
> + * @dev: device to unregister
> + *
> + * This tries to unregister a system framebuffer device if this was registered
> + * by the Generic System Framebuffers. The device will only be unregistered if
> + * it was registered by sysfb_init(), otherwise it will not be unregistered.
> + *
> + * Context: The function can sleep. a @load_lock mutex is acquired to serialize
> + *          against sysfb_init(), that registers a simple framebuffer device and
> + *          sysfb_disable(), that disables the Generic System Framebuffers support.
> + *
> + * Return:
> + * * true          - the device was unregistered successfully
> + * * false         - the device was not unregistered
> + */
> +bool sysfb_try_unregister(struct device *dev)
> +{
> +	bool ret = true;
> +
> +	mutex_lock(&load_lock);
> +	if (!pd || pd != to_platform_device(dev))
> +		return false;
> +
> +	platform_device_unregister(to_platform_device(dev));
> +	pd = NULL;
> +	mutex_unlock(&load_lock);
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(sysfb_try_unregister);
> +
>   static __init int sysfb_init(void)
>   {
>   	struct screen_info *si = &screen_info;
>   	struct simplefb_platform_data mode;
> -	struct platform_device *pd;
>   	const char *name;
>   	bool compatible;
> -	int ret;
> +	int ret = 0;
> +
> +	mutex_lock(&load_lock);
> +	if (disabled)
> +		goto unlock_mutex;
>   
>   	/* try to create a simple-framebuffer device */
>   	compatible = sysfb_parse_mode(si, &mode);
>   	if (compatible) {
>   		pd = sysfb_create_simplefb(si, &mode);
>   		if (!IS_ERR(pd))
> -			return 0;
> +			goto unlock_mutex;
>   	}
>   
>   	/* if the FB is incompatible, create a legacy framebuffer device */
> @@ -60,8 +117,10 @@ static __init int sysfb_init(void)
>   		name = "platform-framebuffer";
>   
>   	pd = platform_device_alloc(name, 0);
> -	if (!pd)
> -		return -ENOMEM;
> +	if (!pd) {
> +		ret = -ENOMEM;
> +		goto unlock_mutex;
> +	}
>   
>   	sysfb_apply_efi_quirks(pd);
>   
> @@ -73,9 +132,11 @@ static __init int sysfb_init(void)
>   	if (ret)
>   		goto err;
>   
> -	return 0;
> +	goto unlock_mutex;
>   err:
>   	platform_device_put(pd);
> +unlock_mutex:
> +	mutex_unlock(&load_lock);
>   	return ret;
>   }
>   
> diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h
> index 708152e9037b..e8c0313fac8f 100644
> --- a/include/linux/sysfb.h
> +++ b/include/linux/sysfb.h
> @@ -55,6 +55,25 @@ struct efifb_dmi_info {
>   	int flags;
>   };
>   
> +#ifdef CONFIG_SYSFB
> +
> +void sysfb_disable(void);
> +bool sysfb_try_unregister(struct device *dev);
> +
> +#else /* CONFIG_SYSFB */
> +
> +static inline void sysfb_disable(void)
> +{
> +
> +}
> +
> +static inline bool sysfb_try_unregister(struct device *dev)
> +{
> +	return false;
> +}
> +
> +#endif /* CONFIG_SYSFB */
> +
>   #ifdef CONFIG_EFI
>   
>   extern struct efifb_dmi_info efifb_dmi_list[];

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 3/5] fbdev: Restart conflicting fb removal loop when unregistering devices

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 4416 bytes --]

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
> Drivers that want to remove registered conflicting framebuffers prior to
> register their own framebuffer, calls remove_conflicting_framebuffers().
> 
> This function takes the registration_lock mutex, to prevent a races when
> drivers register framebuffer devices. But if a conflicting framebuffer
> device is found, the underlaying platform device is unregistered and this
> will lead to the platform driver .remove callback to be called, which in
> turn will call to the unregister_framebuffer() that takes the same lock.
> 
> To prevent this, a struct fb_info.forced_out field was used as indication
> to unregister_framebuffer() whether the mutex has to be grabbed or not.
> 
> A cleaner solution is to drop the lock before platform_device_unregister()
> so unregister_framebuffer() can take it when called from the fbdev driver,
> and just grab the lock again after the device has been registered and do
> a removal loop restart.

I don't see how this patch improves the situation. So far, 
do_remove_conflicting_framebuffers() had no business in maintaining 
locks. And now it's doing this in in a goto-loop where it keeps 
getting/dropping locks.  That's asking for bugs IMHO.

Best regards
Thomas

> 
> Since the framebuffer devices will already be removed, the loop would just
> finish when no more conflicting framebuffers are found.
> 
> Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> ---
> 
> (no changes since v1)
> 
>   drivers/video/fbdev/core/fbmem.c | 22 +++++++++++++++-------
>   include/linux/fb.h               |  1 -
>   2 files changed, 15 insertions(+), 8 deletions(-)
> 
> diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
> index 84427470367b..0bb459258df3 100644
> --- a/drivers/video/fbdev/core/fbmem.c
> +++ b/drivers/video/fbdev/core/fbmem.c
> @@ -1553,6 +1553,7 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
>   {
>   	int i;
>   
> +restart_removal:
>   	/* check all firmware fbs and kick off if the base addr overlaps */
>   	for_each_registered_fb(i) {
>   		struct apertures_struct *gen_aper;
> @@ -1585,12 +1586,23 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
>   				pr_warn("fb%d: no device set\n", i);
>   				do_unregister_framebuffer(registered_fb[i]);
>   			} else if (dev_is_platform(device)) {
> -				registered_fb[i]->forced_out = true;
> +				/*
> +				 * Drop the lock because if the device is unregistered, its
> +				 * driver will call to unregister_framebuffer(), that takes
> +				 * this lock.
> +				 */
> +				mutex_unlock(&registration_lock);
>   				platform_device_unregister(to_platform_device(device));
> +				mutex_lock(&registration_lock);
>   			} else {
>   				pr_warn("fb%d: cannot remove device\n", i);
>   				do_unregister_framebuffer(registered_fb[i]);
>   			}
> +			/*
> +			 * Restart the removal loop now that the device has been
> +			 * unregistered and its associated framebuffer gone.
> +			 */
> +			goto restart_removal;
>   		}
>   	}
>   }
> @@ -1897,13 +1909,9 @@ EXPORT_SYMBOL(register_framebuffer);
>   void
>   unregister_framebuffer(struct fb_info *fb_info)
>   {
> -	bool forced_out = fb_info->forced_out;
> -
> -	if (!forced_out)
> -		mutex_lock(&registration_lock);
> +	mutex_lock(&registration_lock);
>   	do_unregister_framebuffer(fb_info);
> -	if (!forced_out)
> -		mutex_unlock(&registration_lock);
> +	mutex_unlock(&registration_lock);
>   }
>   EXPORT_SYMBOL(unregister_framebuffer);
>   
> diff --git a/include/linux/fb.h b/include/linux/fb.h
> index f95da1af9ff6..b781bc721113 100644
> --- a/include/linux/fb.h
> +++ b/include/linux/fb.h
> @@ -502,7 +502,6 @@ struct fb_info {
>   	} *apertures;
>   
>   	bool skip_vt_switch; /* no VT switch on suspend/resume required */
> -	bool forced_out; /* set when being removed by another driver */
>   };
>   
>   static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 3/5] fbdev: Restart conflicting fb removal loop when unregistering devices

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 4416 bytes --]

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
> Drivers that want to remove registered conflicting framebuffers prior to
> register their own framebuffer, calls remove_conflicting_framebuffers().
> 
> This function takes the registration_lock mutex, to prevent a races when
> drivers register framebuffer devices. But if a conflicting framebuffer
> device is found, the underlaying platform device is unregistered and this
> will lead to the platform driver .remove callback to be called, which in
> turn will call to the unregister_framebuffer() that takes the same lock.
> 
> To prevent this, a struct fb_info.forced_out field was used as indication
> to unregister_framebuffer() whether the mutex has to be grabbed or not.
> 
> A cleaner solution is to drop the lock before platform_device_unregister()
> so unregister_framebuffer() can take it when called from the fbdev driver,
> and just grab the lock again after the device has been registered and do
> a removal loop restart.

I don't see how this patch improves the situation. So far, 
do_remove_conflicting_framebuffers() had no business in maintaining 
locks. And now it's doing this in in a goto-loop where it keeps 
getting/dropping locks.  That's asking for bugs IMHO.

Best regards
Thomas

> 
> Since the framebuffer devices will already be removed, the loop would just
> finish when no more conflicting framebuffers are found.
> 
> Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> ---
> 
> (no changes since v1)
> 
>   drivers/video/fbdev/core/fbmem.c | 22 +++++++++++++++-------
>   include/linux/fb.h               |  1 -
>   2 files changed, 15 insertions(+), 8 deletions(-)
> 
> diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
> index 84427470367b..0bb459258df3 100644
> --- a/drivers/video/fbdev/core/fbmem.c
> +++ b/drivers/video/fbdev/core/fbmem.c
> @@ -1553,6 +1553,7 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
>   {
>   	int i;
>   
> +restart_removal:
>   	/* check all firmware fbs and kick off if the base addr overlaps */
>   	for_each_registered_fb(i) {
>   		struct apertures_struct *gen_aper;
> @@ -1585,12 +1586,23 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
>   				pr_warn("fb%d: no device set\n", i);
>   				do_unregister_framebuffer(registered_fb[i]);
>   			} else if (dev_is_platform(device)) {
> -				registered_fb[i]->forced_out = true;
> +				/*
> +				 * Drop the lock because if the device is unregistered, its
> +				 * driver will call to unregister_framebuffer(), that takes
> +				 * this lock.
> +				 */
> +				mutex_unlock(&registration_lock);
>   				platform_device_unregister(to_platform_device(device));
> +				mutex_lock(&registration_lock);
>   			} else {
>   				pr_warn("fb%d: cannot remove device\n", i);
>   				do_unregister_framebuffer(registered_fb[i]);
>   			}
> +			/*
> +			 * Restart the removal loop now that the device has been
> +			 * unregistered and its associated framebuffer gone.
> +			 */
> +			goto restart_removal;
>   		}
>   	}
>   }
> @@ -1897,13 +1909,9 @@ EXPORT_SYMBOL(register_framebuffer);
>   void
>   unregister_framebuffer(struct fb_info *fb_info)
>   {
> -	bool forced_out = fb_info->forced_out;
> -
> -	if (!forced_out)
> -		mutex_lock(&registration_lock);
> +	mutex_lock(&registration_lock);
>   	do_unregister_framebuffer(fb_info);
> -	if (!forced_out)
> -		mutex_unlock(&registration_lock);
> +	mutex_unlock(&registration_lock);
>   }
>   EXPORT_SYMBOL(unregister_framebuffer);
>   
> diff --git a/include/linux/fb.h b/include/linux/fb.h
> index f95da1af9ff6..b781bc721113 100644
> --- a/include/linux/fb.h
> +++ b/include/linux/fb.h
> @@ -502,7 +502,6 @@ struct fb_info {
>   	} *apertures;
>   
>   	bool skip_vt_switch; /* no VT switch on suspend/resume required */
> -	bool forced_out; /* set when being removed by another driver */
>   };
>   
>   static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 4/5] fbdev: Fix some race conditions between fbmem and sysfb

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 5696 bytes --]

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
> The platform devices registered in sysfb match with a firmware-based fbdev
> or DRM driver, that are used to have early graphics using framebuffers set
> up by the system firmware.
> 
> Real DRM drivers later are probed and remove all conflicting framebuffers,
> leading to these platform devices for generic drivers to be unregistered.
> 
> But the current solution has two issues that this patch fixes:
> 
> 1) It is a layering violation for the fbdev core to unregister a device
>     that was registered by sysfb.

Why? We do this elsewhere and it works nicely.

> 
>     Instead, the sysfb_try_unregister() helper function can be called for
>     sysfb to attempt unregistering the device if is the one registered.

And sysfb_try_unregister() is really just a glorified version of 
platform_device_unregister() IMHO.

> 
> 2) The sysfb_init() function could be called after a DRM driver is probed
>     and requested to unregister devices for drivers with a conflicting fb.
> 
>     To prevent this, disable any future sysfb platform device registration
>     by calling sysfb_disable(), if a driver requested to remove conflicting
>     framebuffers with remove_conflicting_framebuffers().

As I mentioned in another comment, as soon as there's anything else than 
EFI/VESA using the sysfb code the unregistering step is likely to break 
in some way.

Best regards
Thomas

> 
> There are video drivers (e.g: vga16fb) that register their own device and
> don't use the sysfb infrastructure for that, so an unregistration has to
> be forced by fbmem if sysfb_try_unregister() fails to do the unregister.
> 
> Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> ---
> 
> (no changes since v2)
> 
> Changes in v2:
> - Explain in the commit message that fbmem has to unregister the device
>    as fallback if a driver registered the device itself (Daniel Vetter).
> - Also explain that fallback in a comment in the code (Daniel Vetter).
> - Don't encode in fbmem the assumption that sysfb will always register
>    platform devices (Daniel Vetter).
> - Add a FIXME comment about drivers registering devices (Daniel Vetter).
> 
>   drivers/video/fbdev/core/fbmem.c | 42 ++++++++++++++++++++++++++++----
>   1 file changed, 37 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
> index 0bb459258df3..8098305879f8 100644
> --- a/drivers/video/fbdev/core/fbmem.c
> +++ b/drivers/video/fbdev/core/fbmem.c
> @@ -19,6 +19,7 @@
>   #include <linux/kernel.h>
>   #include <linux/major.h>
>   #include <linux/slab.h>
> +#include <linux/sysfb.h>
>   #include <linux/mm.h>
>   #include <linux/mman.h>
>   #include <linux/vt.h>
> @@ -1585,18 +1586,38 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
>   			if (!device) {
>   				pr_warn("fb%d: no device set\n", i);
>   				do_unregister_framebuffer(registered_fb[i]);
> -			} else if (dev_is_platform(device)) {
> +			} else {
>   				/*
>   				 * Drop the lock because if the device is unregistered, its
>   				 * driver will call to unregister_framebuffer(), that takes
>   				 * this lock.
>   				 */
>   				mutex_unlock(&registration_lock);
> -				platform_device_unregister(to_platform_device(device));
> +				/*
> +				 * First attempt the device to be unregistered by sysfb.
> +				 */
> +				if (!sysfb_try_unregister(device)) {
> +					if (dev_is_platform(device)) {
> +						/*
> +						 * FIXME: sysfb didn't register this device, is a platform
> +						 * device registered by a video driver (e.g: vga16fb), so
> +						 * force its unregistration here. A proper fix would be to
> +						 * move all device registration to the sysfb infrastructure
> +						 * or platform code.
> +						 */
> +						platform_device_unregister(to_platform_device(device));
> +					} else {
> +						/*
> +						 * If is not a platform device, at least print a warning. A
> +						 * fix would add to make the code that registered the device
> +						 * to also unregister it.
> +						 */
> +						pr_warn("fb%d: cannot remove device\n", i);
> +						/* call unregister_framebuffer() since the lock was dropped */
> +						unregister_framebuffer(registered_fb[i]);
> +					}
> +				}
>   				mutex_lock(&registration_lock);
> -			} else {
> -				pr_warn("fb%d: cannot remove device\n", i);
> -				do_unregister_framebuffer(registered_fb[i]);
>   			}
>   			/*
>   			 * Restart the removal loop now that the device has been
> @@ -1762,6 +1783,17 @@ int remove_conflicting_framebuffers(struct apertures_struct *a,
>   		do_free = true;
>   	}
>   
> +	/*
> +	 * If a driver asked to unregister a platform device registered by
> +	 * sysfb, then can be assumed that this is a driver for a display
> +	 * that is set up by the system firmware and has a generic driver.
> +	 *
> +	 * Drivers for devices that don't have a generic driver will never
> +	 * ask for this, so let's assume that a real driver for the display
> +	 * was already probed and prevent sysfb to register devices later.
> +	 */
> +	sysfb_disable();
> +
>   	mutex_lock(&registration_lock);
>   	do_remove_conflicting_framebuffers(a, name, primary);
>   	mutex_unlock(&registration_lock);

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 4/5] fbdev: Fix some race conditions between fbmem and sysfb

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 5696 bytes --]

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
> The platform devices registered in sysfb match with a firmware-based fbdev
> or DRM driver, that are used to have early graphics using framebuffers set
> up by the system firmware.
> 
> Real DRM drivers later are probed and remove all conflicting framebuffers,
> leading to these platform devices for generic drivers to be unregistered.
> 
> But the current solution has two issues that this patch fixes:
> 
> 1) It is a layering violation for the fbdev core to unregister a device
>     that was registered by sysfb.

Why? We do this elsewhere and it works nicely.

> 
>     Instead, the sysfb_try_unregister() helper function can be called for
>     sysfb to attempt unregistering the device if is the one registered.

And sysfb_try_unregister() is really just a glorified version of 
platform_device_unregister() IMHO.

> 
> 2) The sysfb_init() function could be called after a DRM driver is probed
>     and requested to unregister devices for drivers with a conflicting fb.
> 
>     To prevent this, disable any future sysfb platform device registration
>     by calling sysfb_disable(), if a driver requested to remove conflicting
>     framebuffers with remove_conflicting_framebuffers().

As I mentioned in another comment, as soon as there's anything else than 
EFI/VESA using the sysfb code the unregistering step is likely to break 
in some way.

Best regards
Thomas

> 
> There are video drivers (e.g: vga16fb) that register their own device and
> don't use the sysfb infrastructure for that, so an unregistration has to
> be forced by fbmem if sysfb_try_unregister() fails to do the unregister.
> 
> Suggested-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
> ---
> 
> (no changes since v2)
> 
> Changes in v2:
> - Explain in the commit message that fbmem has to unregister the device
>    as fallback if a driver registered the device itself (Daniel Vetter).
> - Also explain that fallback in a comment in the code (Daniel Vetter).
> - Don't encode in fbmem the assumption that sysfb will always register
>    platform devices (Daniel Vetter).
> - Add a FIXME comment about drivers registering devices (Daniel Vetter).
> 
>   drivers/video/fbdev/core/fbmem.c | 42 ++++++++++++++++++++++++++++----
>   1 file changed, 37 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
> index 0bb459258df3..8098305879f8 100644
> --- a/drivers/video/fbdev/core/fbmem.c
> +++ b/drivers/video/fbdev/core/fbmem.c
> @@ -19,6 +19,7 @@
>   #include <linux/kernel.h>
>   #include <linux/major.h>
>   #include <linux/slab.h>
> +#include <linux/sysfb.h>
>   #include <linux/mm.h>
>   #include <linux/mman.h>
>   #include <linux/vt.h>
> @@ -1585,18 +1586,38 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a,
>   			if (!device) {
>   				pr_warn("fb%d: no device set\n", i);
>   				do_unregister_framebuffer(registered_fb[i]);
> -			} else if (dev_is_platform(device)) {
> +			} else {
>   				/*
>   				 * Drop the lock because if the device is unregistered, its
>   				 * driver will call to unregister_framebuffer(), that takes
>   				 * this lock.
>   				 */
>   				mutex_unlock(&registration_lock);
> -				platform_device_unregister(to_platform_device(device));
> +				/*
> +				 * First attempt the device to be unregistered by sysfb.
> +				 */
> +				if (!sysfb_try_unregister(device)) {
> +					if (dev_is_platform(device)) {
> +						/*
> +						 * FIXME: sysfb didn't register this device, is a platform
> +						 * device registered by a video driver (e.g: vga16fb), so
> +						 * force its unregistration here. A proper fix would be to
> +						 * move all device registration to the sysfb infrastructure
> +						 * or platform code.
> +						 */
> +						platform_device_unregister(to_platform_device(device));
> +					} else {
> +						/*
> +						 * If is not a platform device, at least print a warning. A
> +						 * fix would add to make the code that registered the device
> +						 * to also unregister it.
> +						 */
> +						pr_warn("fb%d: cannot remove device\n", i);
> +						/* call unregister_framebuffer() since the lock was dropped */
> +						unregister_framebuffer(registered_fb[i]);
> +					}
> +				}
>   				mutex_lock(&registration_lock);
> -			} else {
> -				pr_warn("fb%d: cannot remove device\n", i);
> -				do_unregister_framebuffer(registered_fb[i]);
>   			}
>   			/*
>   			 * Restart the removal loop now that the device has been
> @@ -1762,6 +1783,17 @@ int remove_conflicting_framebuffers(struct apertures_struct *a,
>   		do_free = true;
>   	}
>   
> +	/*
> +	 * If a driver asked to unregister a platform device registered by
> +	 * sysfb, then can be assumed that this is a driver for a display
> +	 * that is set up by the system firmware and has a generic driver.
> +	 *
> +	 * Drivers for devices that don't have a generic driver will never
> +	 * ask for this, so let's assume that a real driver for the display
> +	 * was already probed and prevent sysfb to register devices later.
> +	 */
> +	sysfb_disable();
> +
>   	mutex_lock(&registration_lock);
>   	do_remove_conflicting_framebuffers(a, name, primary);
>   	mutex_unlock(&registration_lock);

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 3/5] fbdev: Restart conflicting fb removal loop when unregistering devices

[Javier Martinez Canillas]

Hello Thomas,

Thanks for the feedback.

On 4/25/22 10:27, Thomas Zimmermann wrote:
> Hi
> 
> Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
>> Drivers that want to remove registered conflicting framebuffers prior to
>> register their own framebuffer, calls remove_conflicting_framebuffers().
>>
>> This function takes the registration_lock mutex, to prevent a races when
>> drivers register framebuffer devices. But if a conflicting framebuffer
>> device is found, the underlaying platform device is unregistered and this
>> will lead to the platform driver .remove callback to be called, which in
>> turn will call to the unregister_framebuffer() that takes the same lock.
>>
>> To prevent this, a struct fb_info.forced_out field was used as indication
>> to unregister_framebuffer() whether the mutex has to be grabbed or not.
>>
>> A cleaner solution is to drop the lock before platform_device_unregister()
>> so unregister_framebuffer() can take it when called from the fbdev driver,
>> and just grab the lock again after the device has been registered and do
>> a removal loop restart.
> 
> I don't see how this patch improves the situation. So far, 
> do_remove_conflicting_framebuffers() had no business in maintaining 
> locks. And now it's doing this in in a goto-loop where it keeps 
> getting/dropping locks.  That's asking for bugs IMHO.
>

It's true that do_remove_conflicting_framebuffers() gets more complicated
with all the locks release/re-acquire but OTOH unregister_framebuffer()
doesn't do conditionally locking, and more importantly the drivers .remove
callback isn't called with the lock held, which IMHO is also quite fragile.

-- 
Best regards,

Javier Martinez Canillas
Linux Engineering
Red Hat

Re: [PATCH v3 3/5] fbdev: Restart conflicting fb removal loop when unregistering devices

[Javier Martinez Canillas]

Hello Thomas,

Thanks for the feedback.

On 4/25/22 10:27, Thomas Zimmermann wrote:
> Hi
> 
> Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:
>> Drivers that want to remove registered conflicting framebuffers prior to
>> register their own framebuffer, calls remove_conflicting_framebuffers().
>>
>> This function takes the registration_lock mutex, to prevent a races when
>> drivers register framebuffer devices. But if a conflicting framebuffer
>> device is found, the underlaying platform device is unregistered and this
>> will lead to the platform driver .remove callback to be called, which in
>> turn will call to the unregister_framebuffer() that takes the same lock.
>>
>> To prevent this, a struct fb_info.forced_out field was used as indication
>> to unregister_framebuffer() whether the mutex has to be grabbed or not.
>>
>> A cleaner solution is to drop the lock before platform_device_unregister()
>> so unregister_framebuffer() can take it when called from the fbdev driver,
>> and just grab the lock again after the device has been registered and do
>> a removal loop restart.
> 
> I don't see how this patch improves the situation. So far, 
> do_remove_conflicting_framebuffers() had no business in maintaining 
> locks. And now it's doing this in in a goto-loop where it keeps 
> getting/dropping locks.  That's asking for bugs IMHO.
>

It's true that do_remove_conflicting_framebuffers() gets more complicated
with all the locks release/re-acquire but OTOH unregister_framebuffer()
doesn't do conditionally locking, and more importantly the drivers .remove
callback isn't called with the lock held, which IMHO is also quite fragile.

-- 
Best regards,

Javier Martinez Canillas
Linux Engineering
Red Hat

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 4794 bytes --]

Hi

Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
> Hello,
> 
> The patches in this series are mostly changes suggested by Daniel Vetter
> to fix some race conditions that exists between the fbdev core (fbmem)
> and sysfb with regard to device registration and removal.
> 
> For example, it is currently possible for sysfb to register a platform
> device after a real DRM driver was registered and requested to remove the
> conflicting framebuffers.
> 
> A symptom of this issue, was worked around with by commit fb561bf9abde
> ("fbdev: Prevent probing generic drivers if a FB is already registered")
> but that's really a hack and should be reverted.

As I mentioned on IRC, I think this series should be merged for the 
reasons I give in the other comments.

> 
> This series attempt to fix it more properly and revert the mentioned hack.
> That will also unblock a pending patch to not make the num_registered_fb
> variable visible to drivers anymore, since that's internal to fbdev core.

Here's as far as I understand the problem:

  1) build DRM/fbdev and sysfb code into the kernel
  2) during boot, load the DRM/fbdev modules and have them acquire I/O 
ranges
  3) afterwards load sysfb and have it register platform devices for the 
generic framebuffers
  4) these devices now conflict with the already-registered DRM/fbdev 
devices

If that is the problem here, let's simply set a sysfb_disable flag in 
sysfb code when the first DRM/fbdev driver first loads. With the flag 
set, sysfb won't create any platform devices. We assume that there are 
now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.

We can set the flag internally from drm_aperture_detach_drivers() [1] 
and do_remove_conflicting_framebuffers() [2].

Best regards
Thomas

[1] 
https://elixir.bootlin.com/linux/v5.17.4/source/drivers/gpu/drm/drm_aperture.c#L253
[2] 
https://elixir.bootlin.com/linux/v5.17.4/source/drivers/video/fbdev/core/fbmem.c#L1559

> 
> Patch #1 is just a trivial preparatory change.
> 
> Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
> to use them.
> 
> Patch #3 changes how is dealt with conflicting framebuffers unregistering,
> rather than having a variable to determine if a lock should be take, it
> just drops the lock before unregistering the platform device.
> 
> Patch #4 fixes the mentioned race conditions and finally patch #5 is the
> revert patch that was posted by Daniel before but he dropped from his set.
> 
> The patches were tested on a rpi4 using different video configurations:
> (simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
> and simpledrm builtin with vc4 built as a module).
> 
> Best regards,
> Javier
> 
> Changes in v3:
> - Rebase on top of latest drm-misc-next branch.
> 
> Changes in v2:
> - Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).
> - Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).
> - Explain in the commit message that fbmem has to unregister the device
>    as fallback if a driver registered the device itself (Daniel Vetter).
> - Also explain that fallback in a comment in the code (Daniel Vetter).
> - Don't encode in fbmem the assumption that sysfb will always register
>    platform devices (Daniel Vetter).
> - Add a FIXME comment about drivers registering devices (Daniel Vetter).
> - Drop RFC prefix since patches were already reviewed by Daniel Vetter.
> - Add Daniel Reviewed-by tags to the patches.
> 
> Daniel Vetter (1):
>    Revert "fbdev: Prevent probing generic drivers if a FB is already
>      registered"
> 
> Javier Martinez Canillas (4):
>    firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer
>    firmware: sysfb: Add helpers to unregister a pdev and disable
>      registration
>    fbdev: Restart conflicting fb removal loop when unregistering devices
>    fbdev: Fix some race conditions between fbmem and sysfb
> 
>   .../driver-api/firmware/other_interfaces.rst  |  6 ++
>   drivers/firmware/sysfb.c                      | 77 +++++++++++++++++--
>   drivers/firmware/sysfb_simplefb.c             | 16 ++--
>   drivers/video/fbdev/core/fbmem.c              | 62 ++++++++++++---
>   drivers/video/fbdev/efifb.c                   | 11 ---
>   drivers/video/fbdev/simplefb.c                | 11 ---
>   include/linux/fb.h                            |  1 -
>   include/linux/sysfb.h                         | 29 +++++--
>   8 files changed, 158 insertions(+), 55 deletions(-)
> 

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 4794 bytes --]

Hi

Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
> Hello,
> 
> The patches in this series are mostly changes suggested by Daniel Vetter
> to fix some race conditions that exists between the fbdev core (fbmem)
> and sysfb with regard to device registration and removal.
> 
> For example, it is currently possible for sysfb to register a platform
> device after a real DRM driver was registered and requested to remove the
> conflicting framebuffers.
> 
> A symptom of this issue, was worked around with by commit fb561bf9abde
> ("fbdev: Prevent probing generic drivers if a FB is already registered")
> but that's really a hack and should be reverted.

As I mentioned on IRC, I think this series should be merged for the 
reasons I give in the other comments.

> 
> This series attempt to fix it more properly and revert the mentioned hack.
> That will also unblock a pending patch to not make the num_registered_fb
> variable visible to drivers anymore, since that's internal to fbdev core.

Here's as far as I understand the problem:

  1) build DRM/fbdev and sysfb code into the kernel
  2) during boot, load the DRM/fbdev modules and have them acquire I/O 
ranges
  3) afterwards load sysfb and have it register platform devices for the 
generic framebuffers
  4) these devices now conflict with the already-registered DRM/fbdev 
devices

If that is the problem here, let's simply set a sysfb_disable flag in 
sysfb code when the first DRM/fbdev driver first loads. With the flag 
set, sysfb won't create any platform devices. We assume that there are 
now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.

We can set the flag internally from drm_aperture_detach_drivers() [1] 
and do_remove_conflicting_framebuffers() [2].

Best regards
Thomas

[1] 
https://elixir.bootlin.com/linux/v5.17.4/source/drivers/gpu/drm/drm_aperture.c#L253
[2] 
https://elixir.bootlin.com/linux/v5.17.4/source/drivers/video/fbdev/core/fbmem.c#L1559

> 
> Patch #1 is just a trivial preparatory change.
> 
> Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
> to use them.
> 
> Patch #3 changes how is dealt with conflicting framebuffers unregistering,
> rather than having a variable to determine if a lock should be take, it
> just drops the lock before unregistering the platform device.
> 
> Patch #4 fixes the mentioned race conditions and finally patch #5 is the
> revert patch that was posted by Daniel before but he dropped from his set.
> 
> The patches were tested on a rpi4 using different video configurations:
> (simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
> and simpledrm builtin with vc4 built as a module).
> 
> Best regards,
> Javier
> 
> Changes in v3:
> - Rebase on top of latest drm-misc-next branch.
> 
> Changes in v2:
> - Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).
> - Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).
> - Explain in the commit message that fbmem has to unregister the device
>    as fallback if a driver registered the device itself (Daniel Vetter).
> - Also explain that fallback in a comment in the code (Daniel Vetter).
> - Don't encode in fbmem the assumption that sysfb will always register
>    platform devices (Daniel Vetter).
> - Add a FIXME comment about drivers registering devices (Daniel Vetter).
> - Drop RFC prefix since patches were already reviewed by Daniel Vetter.
> - Add Daniel Reviewed-by tags to the patches.
> 
> Daniel Vetter (1):
>    Revert "fbdev: Prevent probing generic drivers if a FB is already
>      registered"
> 
> Javier Martinez Canillas (4):
>    firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer
>    firmware: sysfb: Add helpers to unregister a pdev and disable
>      registration
>    fbdev: Restart conflicting fb removal loop when unregistering devices
>    fbdev: Fix some race conditions between fbmem and sysfb
> 
>   .../driver-api/firmware/other_interfaces.rst  |  6 ++
>   drivers/firmware/sysfb.c                      | 77 +++++++++++++++++--
>   drivers/firmware/sysfb_simplefb.c             | 16 ++--
>   drivers/video/fbdev/core/fbmem.c              | 62 ++++++++++++---
>   drivers/video/fbdev/efifb.c                   | 11 ---
>   drivers/video/fbdev/simplefb.c                | 11 ---
>   include/linux/fb.h                            |  1 -
>   include/linux/sysfb.h                         | 29 +++++--
>   8 files changed, 158 insertions(+), 55 deletions(-)
> 

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 5463 bytes --]

Hi

Am 25.04.22 um 10:54 schrieb Thomas Zimmermann:
> Hi
> 
> Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
>> Hello,
>>
>> The patches in this series are mostly changes suggested by Daniel Vetter
>> to fix some race conditions that exists between the fbdev core (fbmem)
>> and sysfb with regard to device registration and removal.
>>
>> For example, it is currently possible for sysfb to register a platform
>> device after a real DRM driver was registered and requested to remove the
>> conflicting framebuffers.
>>
>> A symptom of this issue, was worked around with by commit fb561bf9abde
>> ("fbdev: Prevent probing generic drivers if a FB is already registered")
>> but that's really a hack and should be reverted.
> 
> As I mentioned on IRC, I think this series should be merged for the 
> reasons I give in the other comments.
> 
>>
>> This series attempt to fix it more properly and revert the mentioned 
>> hack.
>> That will also unblock a pending patch to not make the num_registered_fb
>> variable visible to drivers anymore, since that's internal to fbdev core.
> 
> Here's as far as I understand the problem:
> 
>   1) build DRM/fbdev and sysfb code into the kernel
>   2) during boot, load the DRM/fbdev modules and have them acquire I/O 
> ranges
>   3) afterwards load sysfb and have it register platform devices for the 
> generic framebuffers
>   4) these devices now conflict with the already-registered DRM/fbdev 
> devices
> 
> If that is the problem here, let's simply set a sysfb_disable flag in 
> sysfb code when the first DRM/fbdev driver first loads. With the flag 
> set, sysfb won't create any platform devices. We assume that there are 
> now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.
> 
> We can set the flag internally from drm_aperture_detach_drivers() [1] 
> and do_remove_conflicting_framebuffers() [2].

And further thinking about it, it would be better to set such a flag 
after successfully registering a DRM/fbdev device.  So we know that 
there's at least one working display in the system. We don't have to 
rely on generic framebuffers after that.

Best regards
Thomas

> 
> Best regards
> Thomas
> 
> [1] 
> https://elixir.bootlin.com/linux/v5.17.4/source/drivers/gpu/drm/drm_aperture.c#L253 
> 
> [2] 
> https://elixir.bootlin.com/linux/v5.17.4/source/drivers/video/fbdev/core/fbmem.c#L1559 
> 
> 
>>
>> Patch #1 is just a trivial preparatory change.
>>
>> Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
>> to use them.
>>
>> Patch #3 changes how is dealt with conflicting framebuffers 
>> unregistering,
>> rather than having a variable to determine if a lock should be take, it
>> just drops the lock before unregistering the platform device.
>>
>> Patch #4 fixes the mentioned race conditions and finally patch #5 is the
>> revert patch that was posted by Daniel before but he dropped from his 
>> set.
>>
>> The patches were tested on a rpi4 using different video configurations:
>> (simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
>> and simpledrm builtin with vc4 built as a module).
>>
>> Best regards,
>> Javier
>>
>> Changes in v3:
>> - Rebase on top of latest drm-misc-next branch.
>>
>> Changes in v2:
>> - Rebase on top of latest drm-misc-next and fix conflicts (Daniel 
>> Vetter).
>> - Add kernel-doc comments and include in other_interfaces.rst (Daniel 
>> Vetter).
>> - Explain in the commit message that fbmem has to unregister the device
>>    as fallback if a driver registered the device itself (Daniel Vetter).
>> - Also explain that fallback in a comment in the code (Daniel Vetter).
>> - Don't encode in fbmem the assumption that sysfb will always register
>>    platform devices (Daniel Vetter).
>> - Add a FIXME comment about drivers registering devices (Daniel Vetter).
>> - Drop RFC prefix since patches were already reviewed by Daniel Vetter.
>> - Add Daniel Reviewed-by tags to the patches.
>>
>> Daniel Vetter (1):
>>    Revert "fbdev: Prevent probing generic drivers if a FB is already
>>      registered"
>>
>> Javier Martinez Canillas (4):
>>    firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer
>>    firmware: sysfb: Add helpers to unregister a pdev and disable
>>      registration
>>    fbdev: Restart conflicting fb removal loop when unregistering devices
>>    fbdev: Fix some race conditions between fbmem and sysfb
>>
>>   .../driver-api/firmware/other_interfaces.rst  |  6 ++
>>   drivers/firmware/sysfb.c                      | 77 +++++++++++++++++--
>>   drivers/firmware/sysfb_simplefb.c             | 16 ++--
>>   drivers/video/fbdev/core/fbmem.c              | 62 ++++++++++++---
>>   drivers/video/fbdev/efifb.c                   | 11 ---
>>   drivers/video/fbdev/simplefb.c                | 11 ---
>>   include/linux/fb.h                            |  1 -
>>   include/linux/sysfb.h                         | 29 +++++--
>>   8 files changed, 158 insertions(+), 55 deletions(-)
>>
> 

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Thomas Zimmermann]

[-- Attachment #1.1: Type: text/plain, Size: 5463 bytes --]

Hi

Am 25.04.22 um 10:54 schrieb Thomas Zimmermann:
> Hi
> 
> Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
>> Hello,
>>
>> The patches in this series are mostly changes suggested by Daniel Vetter
>> to fix some race conditions that exists between the fbdev core (fbmem)
>> and sysfb with regard to device registration and removal.
>>
>> For example, it is currently possible for sysfb to register a platform
>> device after a real DRM driver was registered and requested to remove the
>> conflicting framebuffers.
>>
>> A symptom of this issue, was worked around with by commit fb561bf9abde
>> ("fbdev: Prevent probing generic drivers if a FB is already registered")
>> but that's really a hack and should be reverted.
> 
> As I mentioned on IRC, I think this series should be merged for the 
> reasons I give in the other comments.
> 
>>
>> This series attempt to fix it more properly and revert the mentioned 
>> hack.
>> That will also unblock a pending patch to not make the num_registered_fb
>> variable visible to drivers anymore, since that's internal to fbdev core.
> 
> Here's as far as I understand the problem:
> 
>   1) build DRM/fbdev and sysfb code into the kernel
>   2) during boot, load the DRM/fbdev modules and have them acquire I/O 
> ranges
>   3) afterwards load sysfb and have it register platform devices for the 
> generic framebuffers
>   4) these devices now conflict with the already-registered DRM/fbdev 
> devices
> 
> If that is the problem here, let's simply set a sysfb_disable flag in 
> sysfb code when the first DRM/fbdev driver first loads. With the flag 
> set, sysfb won't create any platform devices. We assume that there are 
> now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.
> 
> We can set the flag internally from drm_aperture_detach_drivers() [1] 
> and do_remove_conflicting_framebuffers() [2].

And further thinking about it, it would be better to set such a flag 
after successfully registering a DRM/fbdev device.  So we know that 
there's at least one working display in the system. We don't have to 
rely on generic framebuffers after that.

Best regards
Thomas

> 
> Best regards
> Thomas
> 
> [1] 
> https://elixir.bootlin.com/linux/v5.17.4/source/drivers/gpu/drm/drm_aperture.c#L253 
> 
> [2] 
> https://elixir.bootlin.com/linux/v5.17.4/source/drivers/video/fbdev/core/fbmem.c#L1559 
> 
> 
>>
>> Patch #1 is just a trivial preparatory change.
>>
>> Patch #2 add sysfb_disable() and sysfb_try_unregister() helpers for fbmem
>> to use them.
>>
>> Patch #3 changes how is dealt with conflicting framebuffers 
>> unregistering,
>> rather than having a variable to determine if a lock should be take, it
>> just drops the lock before unregistering the platform device.
>>
>> Patch #4 fixes the mentioned race conditions and finally patch #5 is the
>> revert patch that was posted by Daniel before but he dropped from his 
>> set.
>>
>> The patches were tested on a rpi4 using different video configurations:
>> (simpledrm -> vc4 both builtin, only vc4 builtin, only simpledrm builtin
>> and simpledrm builtin with vc4 built as a module).
>>
>> Best regards,
>> Javier
>>
>> Changes in v3:
>> - Rebase on top of latest drm-misc-next branch.
>>
>> Changes in v2:
>> - Rebase on top of latest drm-misc-next and fix conflicts (Daniel 
>> Vetter).
>> - Add kernel-doc comments and include in other_interfaces.rst (Daniel 
>> Vetter).
>> - Explain in the commit message that fbmem has to unregister the device
>>    as fallback if a driver registered the device itself (Daniel Vetter).
>> - Also explain that fallback in a comment in the code (Daniel Vetter).
>> - Don't encode in fbmem the assumption that sysfb will always register
>>    platform devices (Daniel Vetter).
>> - Add a FIXME comment about drivers registering devices (Daniel Vetter).
>> - Drop RFC prefix since patches were already reviewed by Daniel Vetter.
>> - Add Daniel Reviewed-by tags to the patches.
>>
>> Daniel Vetter (1):
>>    Revert "fbdev: Prevent probing generic drivers if a FB is already
>>      registered"
>>
>> Javier Martinez Canillas (4):
>>    firmware: sysfb: Make sysfb_create_simplefb() return a pdev pointer
>>    firmware: sysfb: Add helpers to unregister a pdev and disable
>>      registration
>>    fbdev: Restart conflicting fb removal loop when unregistering devices
>>    fbdev: Fix some race conditions between fbmem and sysfb
>>
>>   .../driver-api/firmware/other_interfaces.rst  |  6 ++
>>   drivers/firmware/sysfb.c                      | 77 +++++++++++++++++--
>>   drivers/firmware/sysfb_simplefb.c             | 16 ++--
>>   drivers/video/fbdev/core/fbmem.c              | 62 ++++++++++++---
>>   drivers/video/fbdev/efifb.c                   | 11 ---
>>   drivers/video/fbdev/simplefb.c                | 11 ---
>>   include/linux/fb.h                            |  1 -
>>   include/linux/sysfb.h                         | 29 +++++--
>>   8 files changed, 158 insertions(+), 55 deletions(-)
>>
> 

-- 
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Maxfeldstr. 5, 90409 Nürnberg, Germany
(HRB 36809, AG Nürnberg)
Geschäftsführer: Ivo Totev

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 840 bytes --]

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Javier Martinez Canillas]

Hello Thomas,

Thanks for the feedback. It was very useful.

On 4/25/22 11:15, Thomas Zimmermann wrote:
> Hi
> 
> Am 25.04.22 um 10:54 schrieb Thomas Zimmermann:
>> Hi
>>
>> Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
>>> Hello,
>>>
>>> The patches in this series are mostly changes suggested by Daniel Vetter
>>> to fix some race conditions that exists between the fbdev core (fbmem)
>>> and sysfb with regard to device registration and removal.
>>>
>>> For example, it is currently possible for sysfb to register a platform
>>> device after a real DRM driver was registered and requested to remove the
>>> conflicting framebuffers.
>>>
>>> A symptom of this issue, was worked around with by commit fb561bf9abde
>>> ("fbdev: Prevent probing generic drivers if a FB is already registered")
>>> but that's really a hack and should be reverted.
>>
>> As I mentioned on IRC, I think this series should be merged for the 
>> reasons I give in the other comments.
>>

You meant that should *not* get merged, as we discussed over IRC.

>>>
>>> This series attempt to fix it more properly and revert the mentioned 
>>> hack.
>>> That will also unblock a pending patch to not make the num_registered_fb
>>> variable visible to drivers anymore, since that's internal to fbdev core.
>>
>> Here's as far as I understand the problem:
>>
>>   1) build DRM/fbdev and sysfb code into the kernel
>>   2) during boot, load the DRM/fbdev modules and have them acquire I/O 
>> ranges
>>   3) afterwards load sysfb and have it register platform devices for the 
>> generic framebuffers
>>   4) these devices now conflict with the already-registered DRM/fbdev 
>> devices
>>

That's correct, yes.

>> If that is the problem here, let's simply set a sysfb_disable flag in 
>> sysfb code when the first DRM/fbdev driver first loads. With the flag 
>> set, sysfb won't create any platform devices. We assume that there are 
>> now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.
>>
>> We can set the flag internally from drm_aperture_detach_drivers() [1] 
>> and do_remove_conflicting_framebuffers() [2].
> 
> And further thinking about it, it would be better to set such a flag 
> after successfully registering a DRM/fbdev device.  So we know that 
> there's at least one working display in the system. We don't have to 
> rely on generic framebuffers after that.
>

Exactly, should be done when the device is registered rather than when
the driver is registered or a call is made to remove the conflicting FB.

I'll rework this series with only the bits for sysfb_disable() and drop
the rest. We can go back to the discussion of the remaining parts later
if that makes sense (I still think that patch 3/5 is a better approach,
but let's defer that for a different series).

-- 
Best regards,

Javier Martinez Canillas
Linux Engineering
Red Hat

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Javier Martinez Canillas]

Hello Thomas,

Thanks for the feedback. It was very useful.

On 4/25/22 11:15, Thomas Zimmermann wrote:
> Hi
> 
> Am 25.04.22 um 10:54 schrieb Thomas Zimmermann:
>> Hi
>>
>> Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
>>> Hello,
>>>
>>> The patches in this series are mostly changes suggested by Daniel Vetter
>>> to fix some race conditions that exists between the fbdev core (fbmem)
>>> and sysfb with regard to device registration and removal.
>>>
>>> For example, it is currently possible for sysfb to register a platform
>>> device after a real DRM driver was registered and requested to remove the
>>> conflicting framebuffers.
>>>
>>> A symptom of this issue, was worked around with by commit fb561bf9abde
>>> ("fbdev: Prevent probing generic drivers if a FB is already registered")
>>> but that's really a hack and should be reverted.
>>
>> As I mentioned on IRC, I think this series should be merged for the 
>> reasons I give in the other comments.
>>

You meant that should *not* get merged, as we discussed over IRC.

>>>
>>> This series attempt to fix it more properly and revert the mentioned 
>>> hack.
>>> That will also unblock a pending patch to not make the num_registered_fb
>>> variable visible to drivers anymore, since that's internal to fbdev core.
>>
>> Here's as far as I understand the problem:
>>
>>   1) build DRM/fbdev and sysfb code into the kernel
>>   2) during boot, load the DRM/fbdev modules and have them acquire I/O 
>> ranges
>>   3) afterwards load sysfb and have it register platform devices for the 
>> generic framebuffers
>>   4) these devices now conflict with the already-registered DRM/fbdev 
>> devices
>>

That's correct, yes.

>> If that is the problem here, let's simply set a sysfb_disable flag in 
>> sysfb code when the first DRM/fbdev driver first loads. With the flag 
>> set, sysfb won't create any platform devices. We assume that there are 
>> now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.
>>
>> We can set the flag internally from drm_aperture_detach_drivers() [1] 
>> and do_remove_conflicting_framebuffers() [2].
> 
> And further thinking about it, it would be better to set such a flag 
> after successfully registering a DRM/fbdev device.  So we know that 
> there's at least one working display in the system. We don't have to 
> rely on generic framebuffers after that.
>

Exactly, should be done when the device is registered rather than when
the driver is registered or a call is made to remove the conflicting FB.

I'll rework this series with only the bits for sysfb_disable() and drop
the rest. We can go back to the discussion of the remaining parts later
if that makes sense (I still think that patch 3/5 is a better approach,
but let's defer that for a different series).

-- 
Best regards,

Javier Martinez Canillas
Linux Engineering
Red Hat

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Daniel Vetter]

On Mon, Apr 25, 2022 at 11:49:13AM +0200, Javier Martinez Canillas wrote:
> Hello Thomas,
> 
> Thanks for the feedback. It was very useful.
> 
> On 4/25/22 11:15, Thomas Zimmermann wrote:
> > Hi
> > 
> > Am 25.04.22 um 10:54 schrieb Thomas Zimmermann:
> >> Hi
> >>
> >> Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
> >>> Hello,
> >>>
> >>> The patches in this series are mostly changes suggested by Daniel Vetter
> >>> to fix some race conditions that exists between the fbdev core (fbmem)
> >>> and sysfb with regard to device registration and removal.
> >>>
> >>> For example, it is currently possible for sysfb to register a platform
> >>> device after a real DRM driver was registered and requested to remove the
> >>> conflicting framebuffers.
> >>>
> >>> A symptom of this issue, was worked around with by commit fb561bf9abde
> >>> ("fbdev: Prevent probing generic drivers if a FB is already registered")
> >>> but that's really a hack and should be reverted.
> >>
> >> As I mentioned on IRC, I think this series should be merged for the 
> >> reasons I give in the other comments.
> >>
> 
> You meant that should *not* get merged, as we discussed over IRC.
> 
> >>>
> >>> This series attempt to fix it more properly and revert the mentioned 
> >>> hack.
> >>> That will also unblock a pending patch to not make the num_registered_fb
> >>> variable visible to drivers anymore, since that's internal to fbdev core.
> >>
> >> Here's as far as I understand the problem:
> >>
> >>   1) build DRM/fbdev and sysfb code into the kernel
> >>   2) during boot, load the DRM/fbdev modules and have them acquire I/O 
> >> ranges
> >>   3) afterwards load sysfb and have it register platform devices for the 
> >> generic framebuffers
> >>   4) these devices now conflict with the already-registered DRM/fbdev 
> >> devices
> >>
> 
> That's correct, yes.
> 
> >> If that is the problem here, let's simply set a sysfb_disable flag in 
> >> sysfb code when the first DRM/fbdev driver first loads. With the flag 
> >> set, sysfb won't create any platform devices. We assume that there are 
> >> now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.
> >>
> >> We can set the flag internally from drm_aperture_detach_drivers() [1] 
> >> and do_remove_conflicting_framebuffers() [2].
> > 
> > And further thinking about it, it would be better to set such a flag 
> > after successfully registering a DRM/fbdev device.  So we know that 
> > there's at least one working display in the system. We don't have to 
> > rely on generic framebuffers after that.
> >
> 
> Exactly, should be done when the device is registered rather than when
> the driver is registered or a call is made to remove the conflicting FB.
> 
> I'll rework this series with only the bits for sysfb_disable() and drop
> the rest. We can go back to the discussion of the remaining parts later
> if that makes sense (I still think that patch 3/5 is a better approach,
> but let's defer that for a different series).

We need to kill sysfb _before_ the driver loads, otherwise you can have
two drivers fighting over each another. And yes that means you might end
up with black screen if the driver load goes wrong, but the two drivers
fighting over each another can also result in black screens. And the
latter isn't fixable any other way (in general at least) than by making
sure the fw stuff is gone before driver load starts in earnest.
-Daniel
-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Daniel Vetter]

On Mon, Apr 25, 2022 at 11:49:13AM +0200, Javier Martinez Canillas wrote:
> Hello Thomas,
> 
> Thanks for the feedback. It was very useful.
> 
> On 4/25/22 11:15, Thomas Zimmermann wrote:
> > Hi
> > 
> > Am 25.04.22 um 10:54 schrieb Thomas Zimmermann:
> >> Hi
> >>
> >> Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:
> >>> Hello,
> >>>
> >>> The patches in this series are mostly changes suggested by Daniel Vetter
> >>> to fix some race conditions that exists between the fbdev core (fbmem)
> >>> and sysfb with regard to device registration and removal.
> >>>
> >>> For example, it is currently possible for sysfb to register a platform
> >>> device after a real DRM driver was registered and requested to remove the
> >>> conflicting framebuffers.
> >>>
> >>> A symptom of this issue, was worked around with by commit fb561bf9abde
> >>> ("fbdev: Prevent probing generic drivers if a FB is already registered")
> >>> but that's really a hack and should be reverted.
> >>
> >> As I mentioned on IRC, I think this series should be merged for the 
> >> reasons I give in the other comments.
> >>
> 
> You meant that should *not* get merged, as we discussed over IRC.
> 
> >>>
> >>> This series attempt to fix it more properly and revert the mentioned 
> >>> hack.
> >>> That will also unblock a pending patch to not make the num_registered_fb
> >>> variable visible to drivers anymore, since that's internal to fbdev core.
> >>
> >> Here's as far as I understand the problem:
> >>
> >>   1) build DRM/fbdev and sysfb code into the kernel
> >>   2) during boot, load the DRM/fbdev modules and have them acquire I/O 
> >> ranges
> >>   3) afterwards load sysfb and have it register platform devices for the 
> >> generic framebuffers
> >>   4) these devices now conflict with the already-registered DRM/fbdev 
> >> devices
> >>
> 
> That's correct, yes.
> 
> >> If that is the problem here, let's simply set a sysfb_disable flag in 
> >> sysfb code when the first DRM/fbdev driver first loads. With the flag 
> >> set, sysfb won't create any platform devices. We assume that there are 
> >> now DRM/fbdev drivers for the framebuffers and sysfb won't be needed.
> >>
> >> We can set the flag internally from drm_aperture_detach_drivers() [1] 
> >> and do_remove_conflicting_framebuffers() [2].
> > 
> > And further thinking about it, it would be better to set such a flag 
> > after successfully registering a DRM/fbdev device.  So we know that 
> > there's at least one working display in the system. We don't have to 
> > rely on generic framebuffers after that.
> >
> 
> Exactly, should be done when the device is registered rather than when
> the driver is registered or a call is made to remove the conflicting FB.
> 
> I'll rework this series with only the bits for sysfb_disable() and drop
> the rest. We can go back to the discussion of the remaining parts later
> if that makes sense (I still think that patch 3/5 is a better approach,
> but let's defer that for a different series).

We need to kill sysfb _before_ the driver loads, otherwise you can have
two drivers fighting over each another. And yes that means you might end
up with black screen if the driver load goes wrong, but the two drivers
fighting over each another can also result in black screens. And the
latter isn't fixable any other way (in general at least) than by making
sure the fw stuff is gone before driver load starts in earnest.
-Daniel
-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

Re: [PATCH v3 0/5] Fix some race conditions that exists between fbmem and sysfb

[Javier Martinez Canillas]

Hello Daniel,

On 4/29/22 09:47, Daniel Vetter wrote:

[snip]

>>
>> Exactly, should be done when the device is registered rather than when
>> the driver is registered or a call is made to remove the conflicting FB.
>>
>> I'll rework this series with only the bits for sysfb_disable() and drop
>> the rest. We can go back to the discussion of the remaining parts later
>> if that makes sense (I still think that patch 3/5 is a better approach,
>> but let's defer that for a different series).
> 
> We need to kill sysfb _before_ the driver loads, otherwise you can have
> two drivers fighting over each another. And yes that means you might end
> up with black screen if the driver load goes wrong, but the two drivers
> fighting over each another can also result in black screens. And the
> latter isn't fixable any other way (in general at least) than by making
> sure the fw stuff is gone before driver load starts in earnest.

Yes, you are correct. I didn't realize all the possible cases when agreed
with Thomas about doing this but tried and found that it's not enough.

I've a full patch-set now and will post as a RFC so we can discuss more.

> -Daniel

-- 
Best regards,

Javier Martinez Canillas
Linux Engineering
Red Hat