iio: envelope-detector: fix use-after-free on device remove
Subsystems (2)
PATCH 1/1 iio: envelope-detector: fix use-after-free on device remove
This driver's remove path never explicitly cancels the delayed work. So it is possible for the delayed work to run after the core has freed the private structure (struct envelope). This is a potential use-after-free.
Fix by adding a devm_add_action callback to the remove path, called right after iio_device_unregister(), which explicitly cancels the delayed work.
This issue was detected with the help of Coccinelle.
--- drivers/iio/adc/envelope-detector.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
drivers/iio/adc/envelope-detector.c +12 -0
@@ -321,6 +321,14 @@ static const struct iio_info envelope_detector_info = { .read_raw = &envelope_detector_read_raw, }; +static void envelope_detector_stop_work (void *data) +{ +struct iio_dev *indio_dev = data; +struct envelope *env =iio_priv (indio_dev); + +cancel_delayed_work_sync (&env->comp_timeout); +} +static int envelope_detector_probe (struct platform_device *pdev) {struct device *dev = &pdev->dev;
@@ -395,6 +403,10 @@ static int envelope_detector_probe(struct platform_device *pdev)return ret; } + ret =devm_add_action (dev, envelope_detector_stop_work, indio_dev); +if (ret) +return ret; +return devm_iio_device_register (dev, indio_dev); }
Signature · 1 line
2.17.1
Quoted 36 lines · Sven Van Asbroeck
This driver's remove path never explicitly cancels the delayed work. So it is possible for the delayed work to run after the core has freed the private structure (struct envelope). This is a potential use-after-free.
Fix by adding a
devm_add_actioncallback to the remove path, called right afteriio_device_unregister(), which explicitly cancels the delayed work.This issue was detected with the help of Coccinelle.
Signed-off-by Sven Van Asbroeck <[email protected]>--- drivers/iio/adc/envelope-detector.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)drivers/iio/adc/envelope-detector.c +8
-0@@ -321,6 +321,14 @@ static const struct iio_info envelope_detector_info = { .read_raw = &envelope_detector_read_raw, }; +static void envelope_detector_stop_work (void *data) +{ +struct iio_dev *indio_dev = data; +struct envelope *env =iio_priv (indio_dev); + +cancel_delayed_work_sync (&env->comp_timeout); +} +static int envelope_detector_probe (struct platform_device *pdev) {struct device *dev = &pdev->dev;
drivers/iio/adc/envelope-detector.c static int envelope_detector_probe(struct platform_device *pdev) · line 408
Quoted 6 lines
drivers/iio/adc/envelope-detector.c +3
-0@@ -395,6 +403,10 @@ static int envelope_detector_probe(struct platform_device *pdev)return ret; } + ret =devm_add_action (dev, envelope_detector_stop_work, indio_dev); +if (ret) +return ret;
Just a random thought. Wouldn't devm_add_action_or_reset() be a better fit? In case adding action results in failure we will not get the chance to cancel work.
Quoted 7 lines
drivers/iio/adc/envelope-detector.c +1
-1+return devm_iio_device_register (dev, indio_dev); } --2.17.1
Quoted 11 lines · Tomasz Duszynski
Quoted 10 lines · Sven Van Asbroeck
This driver's remove path never explicitly cancels the delayed work. So it is possible for the delayed work to run after the core has freed the private structure (struct envelope). This is a potential use-after-free.
Fix by adding a
devm_add_actioncallback to the remove path, called right afteriio_device_unregister(), which explicitly cancels the delayed work.This issue was detected with the help of Coccinelle.
Hi Sven,
(I didn't get the original msg for some reason, so I'm responding to this reply instead)
This is false positive, AFAICT. The delayed work must have finished while envelope_detector_read_raw() holds the read_lock mutex, and it would be highly surprising if the device can go away while it is handling an IIO ->read_raw call. (THAT would be an interesting bug...)
That said, I might be mistaken, but you need to explain a sequence of events that leads to the claimed dangling delayed work. I.e., how do you propose that env->done completes while there is work scheduled? Short of that, and since this is all theory without empirical evidence, this patch gets a NACK from me.
Cheers,
Peter
Quoted 44 lines
Quoted 26 lines
Signed-off-by Sven Van Asbroeck <[email protected]>--- drivers/iio/adc/envelope-detector.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)drivers/iio/adc/envelope-detector.c +8
-0@@ -321,6 +321,14 @@ static const struct iio_info envelope_detector_info = { .read_raw = &envelope_detector_read_raw, }; +static void envelope_detector_stop_work (void *data) +{ +struct iio_dev *indio_dev = data; +struct envelope *env =iio_priv (indio_dev); + +cancel_delayed_work_sync (&env->comp_timeout); +} +static int envelope_detector_probe (struct platform_device *pdev) {struct device *dev = &pdev->dev;drivers/iio/adc/envelope-detector.c static int envelope_detector_probe(struct platform_device *pdev) · line 408
Quoted 6 lines
drivers/iio/adc/envelope-detector.c +3
-0@@ -395,6 +403,10 @@ static int envelope_detector_probe(struct platform_device *pdev)return ret; } + ret =devm_add_action (dev, envelope_detector_stop_work, indio_dev); +if (ret) +return ret;Just a random thought. Wouldn't
devm_add_action_or_reset()be a better fit? In case adding action results in failure we will not get the chance to cancel work.Quoted 7 lines
drivers/iio/adc/envelope-detector.c +1
-1+return devm_iio_device_register (dev, indio_dev); } --2.17.1
Hi Peter,
Quoted 6 lines · Peter Rosin
This is false positive, AFAICT. The delayed work must have finished while
envelope_detector_read_raw()holds theread_lockmutex, and it would be highly surprising if the device can go away while it is handling an IIO ->read_raw call. (THAT would be an interesting bug...)
Quite right. I had completely overlooked the fact that wait_for_completion() cannot finish unless explicitly completed. Unlike wait_for_completion_interruptible().
So yes, this looks like a false positive. My apologies.
Sven