fscrypt: use smp_load_acquire() for ->s_master_keys

Normally smp_store_release() or cmpxchg_release() is paired with
smp_load_acquire().  Sometimes smp_load_acquire() can be replaced with
the more lightweight READ_ONCE().  However, for this to be safe, all the
published memory must only be accessed in a way that involves the
pointer itself.  This may not be the case if allocating the object also
involves initializing a static or global variable, for example.

super_block::s_master_keys is a keyring, which is internal to and is
allocated by the keyrings subsystem.  By using READ_ONCE() for it, we're
relying on internal implementation details of the keyrings subsystem.

Remove this fragile assumption by using smp_load_acquire() instead.

(Note: I haven't seen any real-world problems here.  This change is just
fixing the code to be guaranteed correct and less fragile.)

Fixes: 22d94f493bfb ("fscrypt: add FS_IOC_ADD_ENCRYPTION_KEY ioctl")
Link: https://lore.kernel.org/r/20200721225920.114347-4-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>

diff --git a/fs/crypto/keyring.c b/fs/crypto/keyring.c
index 7f8ac61a20d63e8215880611e0e0feefc301d8e7..71d56f8e28708674517f8066b0d9e955f43057a6 100644 (file)
--- a/fs/crypto/keyring.c
+++ b/fs/crypto/keyring.c
@@ -213,7 +213,11 @@ static int allocate_filesystem_keyring(struct super_block *sb)
        if (IS_ERR(keyring))
                return PTR_ERR(keyring);
 
-       /* Pairs with READ_ONCE() in fscrypt_find_master_key() */
+       /*
+        * Pairs with the smp_load_acquire() in fscrypt_find_master_key().
+        * I.e., here we publish ->s_master_keys with a RELEASE barrier so that
+        * concurrent tasks can ACQUIRE it.
+        */
        smp_store_release(&sb->s_master_keys, keyring);
        return 0;
 }
@@ -234,8 +238,13 @@ struct key *fscrypt_find_master_key(struct super_block *sb,
        struct key *keyring;
        char description[FSCRYPT_MK_DESCRIPTION_SIZE];
 
-       /* pairs with smp_store_release() in allocate_filesystem_keyring() */
-       keyring = READ_ONCE(sb->s_master_keys);
+       /*
+        * Pairs with the smp_store_release() in allocate_filesystem_keyring().
+        * I.e., another task can publish ->s_master_keys concurrently,
+        * executing a RELEASE barrier.  We need to use smp_load_acquire() here
+        * to safely ACQUIRE the memory the other task published.
+        */
+       keyring = smp_load_acquire(&sb->s_master_keys);
        if (keyring == NULL)
                return ERR_PTR(-ENOKEY); /* No keyring yet, so no keys yet. */