watchdog ->release() races
Watchdog drivers tend to do something like that:
foo_open()
{
if (test_and_set_bit(0, &foo_is_open))
return -EBUSY;
...
}foo_write()
{
...
assign foo_expect_close
...
}foo_release()
{
look at foo_expect_close, act accordingly
clear_bit(0, &foo_is_open);
foo_expect_close = 0;
}OK, so it tries to make sure that there's only one opened struct file for the device; fair enough, but what happens if we have
task A: open()/write()/close()
task B: open()/write()/close()
with task A losing CPU just between clear_bit() and clearing foo_expect_close? If it regains CPU just after write() done by task B, we'll get foo_expect_close unexpectedly cleared.
It's obviously racy; I'm not sure if we care about that race, but if we do, there's about 80 drivers that need to be fixed...
Comments?
Quoted 3 lines · Al Viro
It's obviously racy; I'm not sure if we care about that race, but if we do, there's about 80 drivers that need to be fixed...
I suspect the "we don't really care" is the correct answer here. It's not like you can really screw things up by mistake, and if you try to screw this up on purpose, you need to be root anyway to open /dev/watchdog etc.
Linus
Quoted 9 lines · Linus Torvalds
Quoted 3 lines · Al Viro
It's obviously racy; I'm not sure if we care about that race, but if we do, there's about 80 drivers that need to be fixed...
I suspect the "we don't really care" is the correct answer here. It's not like you can really screw things up by mistake, and if you try to screw this up on purpose, you need to be root anyway to open
/dev/watchdogetc.
I'm not sure... It's obviously not a "the sky is falling" kind of thing, but in a situation when task B kills task A, then spins trying to open until open() succeeds... Hell knows; it might be triggerable by somebody not trying to trigger the race on purpose. I really don't know what does the userland side of that thing look like, thus the Cc to linux-wtchdog...
Guenter Roeck
maintainerQuoted 31 lines · Al Viro
Watchdog drivers tend to do something like that:
foo_open(){ if (test_and_set_bit(0, &foo_is_open)) return -EBUSY; ... }
foo_write(){ ... assign foo_expect_close ... }
foo_release(){ look at foo_expect_close, act accordingly clear_bit(0, &foo_is_open); foo_expect_close = 0; }OK, so it tries to make sure that there's only one opened struct file for the device; fair enough, but what happens if we have
task A: open()/write()/close()
task B: open()/write()/close()
with task A losing CPU just betweenclear_bit()and clearingfoo_expect_close? If it regains CPU just afterwrite()done by task B, we'll getfoo_expect_closeunexpectedly cleared.
Quoted 4 lines
It's obviously racy; I'm not sure if we care about that race, but if we do, there's about 80 drivers that need to be fixed...
Comments?
Good catch.
Unless I am missing something, the problem should be fixed for drivers using the watchdog infrastructure. Might be a good incentive to convert the remaining drivers.
There is a race in watchdog_register_device which I think is a bit more serious. See https://patchwork.kernel.org/patch/2400801/.
It is in linux-next, so Linus should get it from Wim's pull request.
Guenter