Skip to contentSkip to conversation

platform: reorder platform_device_del

PATCH Applied Jean Delvare 4 participants 6 messages Feb 18, 2007 – Feb 27, 2007 Driver core

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 platform: reorder platform_device_del

In platform_device_del(), we currently delete the device resources first, then we delete the device itself. This causes a (minor) bug to occur when one unregisters a platform device before unregistering its platform driver, and the driver is requesting (in .probe()) and releasing (in .remove()) a resource of the device. The device resources are already gone by the time the driver gets the chance to release the resources it had been requesting, causing an error like:
Trying to free nonexistent resource <0000000000000295-0000000000000296>

If the platform driver is unregistered first, the problem doesn't occur, as the driver will have the opportunity to release the resources it had requested before the device resources themselves are released. It's a bit odd that unregistering the driver first or the device first doesn't lead to the same result.

So I believe that we should delete the device first in platform_device_del(). I've searched the git history and found that it used to be the case before 2.6.8, but was changed here:

http://www.kernel.org/git/?p=linux/kernel/git/torvalds/old-2.6-bkcvs.git;a=commitdiff;h=96ef7b3689936ee1e64b711511342026a8ce459c

Quoted 7 lines

2004/07/14 16:09:44-07:00 dtor_core
[PATCH] Driver core: Fix OOPS in device_platform_unregister

Driver core: platform_device_unregister should release resources first
and only then call device_unregister, otherwise if there are no more references to the device it will be freed and the fucntion will try to access freed memory.

However we now have an explicit call to put_device() at the end of platform_device_unregister() so I guess the original problem no longer exists and it is safe to revert that change.

---
 drivers/base/platform.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
drivers/base/platform.c +2 -2
@@ -299,13 +299,13 @@ void platform_device_del(struct platform
 	int i;
 
 	if (pdev) {
+		device_del(&pdev->dev);
+
 		for (i = 0; i < pdev->num_resources; i++) {
 			struct resource *r = &pdev->resource[i];
 			if (r->flags & (IORESOURCE_MEM|IORESOURCE_IO))
 				release_resource(r);
 		}
-
-		device_del(&pdev->dev);
 	}
 }
 EXPORT_SYMBOL_GPL(platform_device_del);
Signature · 1 line
Jean Delvare
#1 lore raw

Hi Jean,

Quoted 9 lines · Jean Delvare

In platform_device_del(), we currently delete the device resources first, then we delete the device itself. This causes a (minor) bug to occur when one unregisters a platform device before unregistering its platform driver, and the driver is requesting (in .probe()) and releasing (in .remove()) a resource of the device. The device resources are already gone by the time the driver gets the chance to release the resources it had been requesting, causing an error like:
Trying to free nonexistent resource <0000000000000295-0000000000000296>

Quoted 5 lines

If the platform driver is unregistered first, the problem doesn't occur, as the driver will have the opportunity to release the resources it had requested before the device resources themselves are released. It's a bit odd that unregistering the driver first or the device first doesn't lead to the same result.

I am not sure that this is correct argument. Why does a driver request and release device's resources? "Higher power" has already requested these resources for the device and this is not drivers task to free them. However you are right that we should not free resources until device is marked for deletion and driver's ->remove() method completes but I would not rely on surrounding code for keeping an extra reference and would just take one explicitely in platform_device_del().

Signature · 1 line
Dmitry
#2 lore raw

Hi Dmitry,

Quoted 16 lines · Dmitry Torokhov
Quoted 9 lines · Jean Delvare

In platform_device_del(), we currently delete the device resources first, then we delete the device itself. This causes a (minor) bug to occur when one unregisters a platform device before unregistering its platform driver, and the driver is requesting (in .probe()) and releasing (in .remove()) a resource of the device. The device resources are already gone by the time the driver gets the chance to release the resources it had been requesting, causing an error like:
Trying to free nonexistent resource <0000000000000295-0000000000000296>

Quoted 5 lines

If the platform driver is unregistered first, the problem doesn't occur, as the driver will have the opportunity to release the resources it had requested before the device resources themselves are released. It's a bit odd that unregistering the driver first or the device first doesn't lead to the same result.

Quoted 4 lines

I am not sure that this is correct argument. Why does a driver request and release device's resources? "Higher power" has already requested these resources for the device and this is not drivers task to free them.

My understanding is that, in the device driver model, devices _declare_ resources, and it's up to the drivers to actually request the ones they wish to use. Looking at /proc/ioports, this hierarchy is quite visible. And while not all platform drivers actually request their device's resource, quite a few do (I counted 95 out of 228), so I'm definitely not the only one thinking it is the right thing to do.

If the intent was that devices request the resources and the drivers don't have to care, then a driver requesting a device's resource should be returned an error. Instead, it works fine, which make me confident that I got the idea right.

Quoted 4 lines

However you are right that we should not free resources until
device is marked for deletion and driver's ->remove() method completes but I would not rely on surrounding code for keeping an extra reference and would just take one explicitely in platform_device_del().

You mean that you wouldn't trust the rest of the platform driver core, which lives in the same source file, to do the right thing? That's being too defensive IMHO, and I don't think we usually do that. Greg?

Signature · 1 line
Jean Delvare
#3 lore raw

Hi Jean,

Quoted 31 lines · Jean Delvare

Hi Dmitry,

Quoted 16 lines · Dmitry Torokhov
Quoted 9 lines · Jean Delvare

In platform_device_del(), we currently delete the device resources first, then we delete the device itself. This causes a (minor) bug to occur when one unregisters a platform device before unregistering its platform driver, and the driver is requesting (in .probe()) and releasing (in .remove()) a resource of the device. The device resources are already gone by the time the driver gets the chance to release the resources it had been requesting, causing an error like:
Trying to free nonexistent resource <0000000000000295-0000000000000296>

Quoted 5 lines

If the platform driver is unregistered first, the problem doesn't occur, as the driver will have the opportunity to release the resources it had requested before the device resources themselves are released. It's a bit odd that unregistering the driver first or the device first doesn't lead to the same result.

Quoted 4 lines

I am not sure that this is correct argument. Why does a driver request and release device's resources? "Higher power" has already requested these resources for the device and this is not drivers task to free them.

My understanding is that, in the device driver model, devices _declare_ resources, and it's up to the drivers to actually request the ones they wish to use. Looking at /proc/ioports, this hierarchy is quite visible. And while not all platform drivers actually request their device's resource, quite a few do (I counted 95 out of 228), so I'm definitely not the only one thinking it is the right thing to do.

Quoted 4 lines

If the intent was that devices request the resources and the drivers don't have to care, then a driver requesting a device's resource should be returned an error. Instead, it works fine, which make me confident that I got the idea right.

But the thing is that when you add resources to a platofrm device it is platform_device_add() that marks resources as busy and therefore it is not driver's task to delete them. If you want driver to request resources you better pass them through a private data structure attached to a device.

The attached resources are normally used by arch setup codes that posess the knowledge about whether a device is present on a box and what IO port or memory region is used. The device is usualy there and its resources fixed and not available to anyone else even if there is no driver to actually control the device.

Quoted 10 lines
Quoted 5 lines

However you are right that we should not free resources until
device is marked for deletion and driver's ->remove() method completes but I would not rely on surrounding code for keeping an extra reference and would just take one explicitely in platform_device_del().

You mean that you wouldn't trust the rest of the platform driver core, which lives in the same source file, to do the right thing? That's being too defensive IMHO, and I don't think we usually do that. Greg?

platform_device_del() is public so all bets are off...

Signature · 1 line
Dmitry
#4 lore raw

Hi Dmitry,

Quoted 2 lines · Dmitry Torokhov

But the thing is that when you add resources to a platofrm device it is platform_device_add() that marks resources as busy and therefore it

No, devices declare the resources, but do not mark them as busy. Otherwise any further attempt to request them would fail, which isn't the case.

Quoted 3 lines

is not driver's task to delete them. If you want driver to request resources you better pass them through a private data structure attached to a device.

The driver isn't deleting the resources, it is marking them as no longer busy.

We can't seem to agree on this point. Can someone else who is familiar with the new resource model please shed some light?

Quoted 5 lines

The attached resources are normally used by arch setup codes that posess the knowledge about whether a device is present on a box and what IO port or memory region is used. The device is usualy there and its resources fixed and not available to anyone else even if there is no driver to actually control the device.

That we agree on.

Quoted 11 lines
Quoted 9 lines
Quoted 4 lines

However you are right that we should not free resources until
device is marked for deletion and driver's ->remove() method completes but I would not rely on surrounding code for keeping an extra reference and would just take one explicitely in platform_device_del().

You mean that you wouldn't trust the rest of the platform driver core, which lives in the same source file, to do the right thing? That's being too defensive IMHO, and I don't think we usually do that. Greg?

platform_device_del() is public so all bets are off...

Good point, I had missed that fact. However, I've now checked all the callers and found that they all call platform_device_put() right after platform_device_del(), so we're safe. And they have to, otherwise their code is broken. It's always in an error path, as this appears to the only legitimate use for platform_device_del(). So I really don't see the benefit of taking an additional reference in platform_device_del "just in case". If it ever makes a difference, it means the caller code is badly broken anyway, so why bother?

platform_device_put has the following comment: "This function must _only_ be externally called in error cases. All other usage is a bug." As I understand it, we could/should add this to platform_device_del too, to discourage the bogus use cases you fear could happen. Hence an updated patch:

* * * * *

In platform_device_del(), we currently delete the device resources first, then we delete the device itself. This causes a (minor) bug to occur when one unregisters a platform device before unregistering its platform driver, and the driver is requesting (in .probe()) and releasing (in .remove()) a resource of the device. The device resources are already gone by the time the driver gets the chance to release the resources it had been requesting, causing an error like:
Trying to free nonexistent resource <0000000000000295-0000000000000296>

If the platform driver is unregistered first, the problem doesn't occur, as the driver will have the opportunity to release the resources it had requested before the device resources themselves are released. It's a bit odd that unregistering the driver first or the device first doesn't lead to the same result.

So I believe that we should delete the device first in platform_device_del(). I've searched the git history and found that it used to be the case before 2.6.8, but was changed here:

http://www.kernel.org/git/?p=linux/kernel/git/torvalds/old-2.6-bkcvs.git;a=commitdiff;h=96ef7b3689936ee1e64b711511342026a8ce459c

Quoted 7 lines

2004/07/14 16:09:44-07:00 dtor_core
[PATCH] Driver core: Fix OOPS in device_platform_unregister

Driver core: platform_device_unregister should release resources first
and only then call device_unregister, otherwise if there are no more references to the device it will be freed and the fucntion will try to access freed memory.

However we now have an explicit call to put_device() at the end of platform_device_unregister() so I guess the original problem no longer exists and it is safe to revert that change.

---
 drivers/base/platform.c |    8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
drivers/base/platform.c +5 -3
@@ -292,20 +292,22 @@ EXPORT_SYMBOL_GPL(platform_device_add);
  *	@pdev:	platform device we're removing
  *
  *	Note that this function will also release all memory- and port-based
- *	resources owned by the device (@dev->resource).
+ *	resources owned by the device (@dev->resource).  This function
+ *	must _only_ be externally called in error cases.  All other usage
+ *	is a bug.
  */
 void platform_device_del(struct platform_device *pdev)
 {
 	int i;
 
 	if (pdev) {
+		device_del(&pdev->dev);
+
 		for (i = 0; i < pdev->num_resources; i++) {
 			struct resource *r = &pdev->resource[i];
 			if (r->flags & (IORESOURCE_MEM|IORESOURCE_IO))
 				release_resource(r);
 		}
-
-		device_del(&pdev->dev);
 	}
 }
 EXPORT_SYMBOL_GPL(platform_device_del);
Signature · 1 line
Jean Delvare
#5 lore raw

patch platform-reorder-platform_device_del.patch added to gregkh-2.6 tree

This is a note to let you know that I've just added the patch titled

Subject: platform: reorder platform_device_del

to my gregkh-2.6 tree. Its filename is

platform-reorder-platform_device_del.patch

This tree can be found at
http://www.kernel.org/pub/linux/kernel/people/gregkh/gregkh-2.6/patches/

Quoted 1 line

From [email protected] Tue Feb 20 13:55:29 2007

From: Jean Delvare <[email protected]>
Date: Tue, 20 Feb 2007 22:55:06 +0100
Subject: platform: reorder platform_device_del
To: "Dmitry Torokhov" <[email protected]>
Cc: "Greg Kroah-Hartman" <[email protected]>, LKML <[email protected]>
Message-ID: <[email protected]>

In platform_device_del(), we currently delete the device resources first, then we delete the device itself. This causes a (minor) bug to occur when one unregisters a platform device before unregistering its platform driver, and the driver is requesting (in .probe()) and releasing (in .remove()) a resource of the device. The device resources are already gone by the time the driver gets the chance to release the resources it had been requesting, causing an error like:
Trying to free nonexistent resource <0000000000000295-0000000000000296>

If the platform driver is unregistered first, the problem doesn't occur, as the driver will have the opportunity to release the resources it had requested before the device resources themselves are released. It's a bit odd that unregistering the driver first or the device first doesn't lead to the same result.

So I believe that we should delete the device first in platform_device_del(). I've searched the git history and found that it used to be the case before 2.6.8, but was changed here:

http://www.kernel.org/git/?p=linux/kernel/git/torvalds/old-2.6-bkcvs.git;a=commitdiff;h=96ef7b3689936ee1e64b711511342026a8ce459c

Quoted 7 lines

2004/07/14 16:09:44-07:00 dtor_core
[PATCH] Driver core: Fix OOPS in device_platform_unregister

Driver core: platform_device_unregister should release resources first
and only then call device_unregister, otherwise if there are no more references to the device it will be freed and the fucntion will try to access freed memory.

However we now have an explicit call to put_device() at the end of platform_device_unregister() so I guess the original problem no longer exists and it is safe to revert that change.

---
 drivers/base/platform.c |    8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
drivers/base/platform.c +5 -3
@@ -292,20 +292,22 @@ EXPORT_SYMBOL_GPL(platform_device_add);
  *	@pdev:	platform device we're removing
  *
  *	Note that this function will also release all memory- and port-based
- *	resources owned by the device (@dev->resource).
+ *	resources owned by the device (@dev->resource).  This function
+ *	must _only_ be externally called in error cases.  All other usage
+ *	is a bug.
  */
 void platform_device_del(struct platform_device *pdev)
 {
 	int i;
 
 	if (pdev) {
+		device_del(&pdev->dev);
+
 		for (i = 0; i < pdev->num_resources; i++) {
 			struct resource *r = &pdev->resource[i];
 			if (r->flags & (IORESOURCE_MEM|IORESOURCE_IO))
 				release_resource(r);
 		}
-
-		device_del(&pdev->dev);
 	}
 }
 EXPORT_SYMBOL_GPL(platform_device_del);

Patches currently in gregkh-2.6 which might be from [email protected] are