Mark Rutland <[email protected]> wrote:
> From a quick look at key_lookup(), the following looks very suspicious:
>
> found:
> /* pretend it doesn't exist if it is awaiting deletion */
> if (refcount_read(&key->usage) == 0)
> goto not_found;
>
> /* this races with key_put(), but that doesn't matter since key_put()
> * doesn't actually change the key
> */
> __key_get(key);
>
> ... as if we can race with key_put(), we can see a zero refcount here,
> and the race *does* matter.
No, it doesn't.
If key_put() reduces a refcount to 0, it doesn't do anything other than poke
the gc thread:
void key_put(struct key *key)
{
if (key) {
key_check(key);
if (refcount_dec_and_test(&key->usage))
schedule_work(&key_gc_work);
}
}
in particular, no indication of the reduced key is passed.
The gc thread scans the entire key serial tree under the key_serial_lock
looking for keys that are no longer ref'd. No one else is allowed to remove
keys from the tree. This means that the gc thread can safely leave a cursor
pointing into the midst of the tree with no locks held whilst it yields to the
scheduler.
The code you quoted above in key_lookup() is inside the key_serial_lock, so it
prevents the gc thread from culling a key when it resurrects it.
So the problem isn't the key code, it's the refcount code.
As I've said before, the refcount code needs an increment op that permits
inc-from-0. In this case, it's perfectly okay.
David
