SELinux: requesting no permissions in avc_has_perm_noaudit is a BUG()
[linux-2.6.git] / security / keys / keyring.c
index e2ab4f8..88292e3 100644 (file)
@@ -1,6 +1,6 @@
 /* keyring.c: keyring handling
  *
- * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
+ * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
  *
  * This program is free software; you can redistribute it and/or
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/security.h>
 #include <linux/seq_file.h>
 #include <linux/err.h>
 #include <asm/uaccess.h>
@@ -47,8 +48,8 @@ static inline unsigned keyring_hash(const char *desc)
  */
 static int keyring_instantiate(struct key *keyring,
                               const void *data, size_t datalen);
-static int keyring_duplicate(struct key *keyring, const struct key *source);
 static int keyring_match(const struct key *keyring, const void *criterion);
+static void keyring_revoke(struct key *keyring);
 static void keyring_destroy(struct key *keyring);
 static void keyring_describe(const struct key *keyring, struct seq_file *m);
 static long keyring_read(const struct key *keyring,
@@ -58,18 +59,20 @@ struct key_type key_type_keyring = {
        .name           = "keyring",
        .def_datalen    = sizeof(struct keyring_list),
        .instantiate    = keyring_instantiate,
-       .duplicate      = keyring_duplicate,
        .match          = keyring_match,
+       .revoke         = keyring_revoke,
        .destroy        = keyring_destroy,
        .describe       = keyring_describe,
        .read           = keyring_read,
 };
 
+EXPORT_SYMBOL(key_type_keyring);
+
 /*
  * semaphore to serialise link/link calls to prevent two link calls in parallel
  * introducing a cycle
  */
-DECLARE_RWSEM(keyring_serialise_link_sem);
+static DECLARE_RWSEM(keyring_serialise_link_sem);
 
 /*****************************************************************************/
 /*
@@ -119,55 +122,6 @@ static int keyring_instantiate(struct key *keyring,
 
 /*****************************************************************************/
 /*
- * duplicate the list of subscribed keys from a source keyring into this one
- */
-static int keyring_duplicate(struct key *keyring, const struct key *source)
-{
-       struct keyring_list *sklist, *klist;
-       unsigned max;
-       size_t size;
-       int loop, ret;
-
-       const unsigned limit =
-               (PAGE_SIZE - sizeof(*klist)) / sizeof(struct key);
-
-       ret = 0;
-       sklist = source->payload.subscriptions;
-
-       if (sklist && sklist->nkeys > 0) {
-               max = sklist->nkeys;
-               BUG_ON(max > limit);
-
-               max = (max + 3) & ~3;
-               if (max > limit)
-                       max = limit;
-
-               ret = -ENOMEM;
-               size = sizeof(*klist) + sizeof(struct key) * max;
-               klist = kmalloc(size, GFP_KERNEL);
-               if (!klist)
-                       goto error;
-
-               klist->maxkeys = max;
-               klist->nkeys = sklist->nkeys;
-               memcpy(klist->keys,
-                      sklist->keys,
-                      sklist->nkeys * sizeof(struct key));
-
-               for (loop = klist->nkeys - 1; loop >= 0; loop--)
-                       atomic_inc(&klist->keys[loop]->usage);
-
-               keyring->payload.subscriptions = klist;
-               ret = 0;
-       }
-
- error:
-       return ret;
-
-} /* end keyring_duplicate() */
-
-/*****************************************************************************/
-/*
  * match keyrings on their name
  */
 static int keyring_match(const struct key *keyring, const void *description)
@@ -188,11 +142,15 @@ static void keyring_destroy(struct key *keyring)
 
        if (keyring->description) {
                write_lock(&keyring_name_lock);
-               list_del(&keyring->type_data.link);
+
+               if (keyring->type_data.link.next != NULL &&
+                   !list_empty(&keyring->type_data.link))
+                       list_del(&keyring->type_data.link);
+
                write_unlock(&keyring_name_lock);
        }
 
-       klist = keyring->payload.subscriptions;
+       klist = rcu_dereference(keyring->payload.subscriptions);
        if (klist) {
                for (loop = klist->nkeys - 1; loop >= 0; loop--)
                        key_put(klist->keys[loop]);
@@ -216,17 +174,20 @@ static void keyring_describe(const struct key *keyring, struct seq_file *m)
                seq_puts(m, "[anon]");
        }
 
-       klist = keyring->payload.subscriptions;
+       rcu_read_lock();
+       klist = rcu_dereference(keyring->payload.subscriptions);
        if (klist)
                seq_printf(m, ": %u/%u", klist->nkeys, klist->maxkeys);
        else
                seq_puts(m, ": empty");
+       rcu_read_unlock();
 
 } /* end keyring_describe() */
 
 /*****************************************************************************/
 /*
  * read a list of key IDs from the keyring's contents
+ * - the keyring's semaphore is read-locked
  */
 static long keyring_read(const struct key *keyring,
                         char __user *buffer, size_t buflen)
@@ -237,7 +198,7 @@ static long keyring_read(const struct key *keyring,
        int loop, ret;
 
        ret = 0;
-       klist = keyring->payload.subscriptions;
+       klist = rcu_dereference(keyring->payload.subscriptions);
 
        if (klist) {
                /* calculate how much data we could return */
@@ -283,16 +244,19 @@ static long keyring_read(const struct key *keyring,
  * allocate a keyring and link into the destination keyring
  */
 struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
-                         int not_in_quota, struct key *dest)
+                         struct task_struct *ctx, unsigned long flags,
+                         struct key *dest)
 {
        struct key *keyring;
        int ret;
 
        keyring = key_alloc(&key_type_keyring, description,
-                           uid, gid, KEY_USR_ALL, not_in_quota);
+                           uid, gid, ctx,
+                           (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
+                           flags);
 
        if (!IS_ERR(keyring)) {
-               ret = key_instantiate_and_link(keyring, NULL, 0, dest);
+               ret = key_instantiate_and_link(keyring, NULL, 0, dest, NULL);
                if (ret < 0) {
                        key_put(keyring);
                        keyring = ERR_PTR(ret);
@@ -310,48 +274,57 @@ struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
  * - we only find keys on which we have search permission
  * - we use the supplied match function to see if the description (or other
  *   feature of interest) matches
- * - we readlock the keyrings as we search down the tree
+ * - we rely on RCU to prevent the keyring lists from disappearing on us
  * - we return -EAGAIN if we didn't find any matching key
  * - we return -ENOKEY if we only found negative matching keys
+ * - we propagate the possession attribute from the keyring ref to the key ref
  */
-struct key *keyring_search_aux(struct key *keyring,
-                              struct key_type *type,
-                              const void *description,
-                              key_match_func_t match)
+key_ref_t keyring_search_aux(key_ref_t keyring_ref,
+                            struct task_struct *context,
+                            struct key_type *type,
+                            const void *description,
+                            key_match_func_t match)
 {
        struct {
-               struct key *keyring;
+               struct keyring_list *keylist;
                int kix;
        } stack[KEYRING_SEARCH_MAX_DEPTH];
 
        struct keyring_list *keylist;
        struct timespec now;
-       struct key *key;
+       unsigned long possessed;
+       struct key *keyring, *key;
+       key_ref_t key_ref;
        long err;
-       int sp, psp, kix;
+       int sp, kix;
 
+       keyring = key_ref_to_ptr(keyring_ref);
+       possessed = is_key_possessed(keyring_ref);
        key_check(keyring);
 
        /* top keyring must have search permission to begin the search */
-       key = ERR_PTR(-EACCES);
-       if (!key_permission(keyring, KEY_SEARCH))
+        err = key_task_permission(keyring_ref, context, KEY_SEARCH);
+       if (err < 0) {
+               key_ref = ERR_PTR(err);
                goto error;
+       }
 
-       key = ERR_PTR(-ENOTDIR);
+       key_ref = ERR_PTR(-ENOTDIR);
        if (keyring->type != &key_type_keyring)
                goto error;
 
+       rcu_read_lock();
+
        now = current_kernel_time();
        err = -EAGAIN;
        sp = 0;
 
        /* start processing a new keyring */
- descend:
-       read_lock(&keyring->lock);
-       if (keyring->flags & KEY_FLAG_REVOKED)
+descend:
+       if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
                goto not_this_keyring;
 
-       keylist = keyring->payload.subscriptions;
+       keylist = rcu_dereference(keyring->payload.subscriptions);
        if (!keylist)
                goto not_this_keyring;
 
@@ -364,7 +337,7 @@ struct key *keyring_search_aux(struct key *keyring,
                        continue;
 
                /* skip revoked keys and expired keys */
-               if (key->flags & KEY_FLAG_REVOKED)
+               if (test_bit(KEY_FLAG_REVOKED, &key->flags))
                        continue;
 
                if (key->expiry && now.tv_sec >= key->expiry)
@@ -375,11 +348,12 @@ struct key *keyring_search_aux(struct key *keyring,
                        continue;
 
                /* key must have search permissions */
-               if (!key_permission(key, KEY_SEARCH))
+               if (key_task_permission(make_key_ref(key, possessed),
+                                       context, KEY_SEARCH) < 0)
                        continue;
 
                /* we set a different error code if we find a negative key */
-               if (key->flags & KEY_FLAG_NEGATIVE) {
+               if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) {
                        err = -ENOKEY;
                        continue;
                }
@@ -389,70 +363,55 @@ struct key *keyring_search_aux(struct key *keyring,
 
        /* search through the keyrings nested in this one */
        kix = 0;
- ascend:
-       while (kix < keylist->nkeys) {
+ascend:
+       for (; kix < keylist->nkeys; kix++) {
                key = keylist->keys[kix];
                if (key->type != &key_type_keyring)
-                       goto next;
+                       continue;
 
                /* recursively search nested keyrings
                 * - only search keyrings for which we have search permission
                 */
                if (sp >= KEYRING_SEARCH_MAX_DEPTH)
-                       goto next;
-
-               if (!key_permission(key, KEY_SEARCH))
-                       goto next;
+                       continue;
 
-               /* evade loops in the keyring tree */
-               for (psp = 0; psp < sp; psp++)
-                       if (stack[psp].keyring == keyring)
-                               goto next;
+               if (key_task_permission(make_key_ref(key, possessed),
+                                       context, KEY_SEARCH) < 0)
+                       continue;
 
                /* stack the current position */
-               stack[sp].keyring = keyring;
+               stack[sp].keylist = keylist;
                stack[sp].kix = kix;
                sp++;
 
                /* begin again with the new keyring */
                keyring = key;
                goto descend;
-
-       next:
-               kix++;
        }
 
        /* the keyring we're looking at was disqualified or didn't contain a
         * matching key */
- not_this_keyring:
-       read_unlock(&keyring->lock);
-
+not_this_keyring:
        if (sp > 0) {
                /* resume the processing of a keyring higher up in the tree */
                sp--;
-               keyring = stack[sp].keyring;
-               keylist = keyring->payload.subscriptions;
+               keylist = stack[sp].keylist;
                kix = stack[sp].kix + 1;
                goto ascend;
        }
 
-       key = ERR_PTR(err);
-       goto error;
+       key_ref = ERR_PTR(err);
+       goto error_2;
 
        /* we found a viable match */
- found:
+found:
        atomic_inc(&key->usage);
-       read_unlock(&keyring->lock);
-
-       /* unwind the keyring stack */
-       while (sp > 0) {
-               sp--;
-               read_unlock(&stack[sp].keyring->lock);
-       }
-
        key_check(key);
- error:
-       return key;
+       key_ref = make_key_ref(key, possessed);
+error_2:
+       rcu_read_unlock();
+error:
+       return key_ref;
 
 } /* end keyring_search_aux() */
 
@@ -465,11 +424,15 @@ struct key *keyring_search_aux(struct key *keyring,
  * - we return -EAGAIN if we didn't find any matching key
  * - we return -ENOKEY if we only found negative matching keys
  */
-struct key *keyring_search(struct key *keyring,
-                          struct key_type *type,
-                          const char *description)
+key_ref_t keyring_search(key_ref_t keyring,
+                        struct key_type *type,
+                        const char *description)
 {
-       return keyring_search_aux(keyring, type, description, type->match);
+       if (!type->match)
+               return ERR_PTR(-ENOKEY);
+
+       return keyring_search_aux(keyring, current,
+                                 type, description, type->match);
 
 } /* end keyring_search() */
 
@@ -479,37 +442,46 @@ EXPORT_SYMBOL(keyring_search);
 /*
  * search the given keyring only (no recursion)
  * - keyring must be locked by caller
+ * - caller must guarantee that the keyring is a keyring
  */
-struct key *__keyring_search_one(struct key *keyring,
-                                const struct key_type *ktype,
-                                const char *description,
-                                key_perm_t perm)
+key_ref_t __keyring_search_one(key_ref_t keyring_ref,
+                              const struct key_type *ktype,
+                              const char *description,
+                              key_perm_t perm)
 {
        struct keyring_list *klist;
-       struct key *key;
+       unsigned long possessed;
+       struct key *keyring, *key;
        int loop;
 
-       klist = keyring->payload.subscriptions;
+       keyring = key_ref_to_ptr(keyring_ref);
+       possessed = is_key_possessed(keyring_ref);
+
+       rcu_read_lock();
+
+       klist = rcu_dereference(keyring->payload.subscriptions);
        if (klist) {
                for (loop = 0; loop < klist->nkeys; loop++) {
                        key = klist->keys[loop];
 
                        if (key->type == ktype &&
-                           key->type->match(key, description) &&
-                           key_permission(key, perm) &&
-                           !(key->flags & KEY_FLAG_REVOKED)
+                           (!key->type->match ||
+                            key->type->match(key, description)) &&
+                           key_permission(make_key_ref(key, possessed),
+                                          perm) == 0 &&
+                           !test_bit(KEY_FLAG_REVOKED, &key->flags)
                            )
                                goto found;
                }
        }
 
-       key = ERR_PTR(-ENOKEY);
-       goto error;
+       rcu_read_unlock();
+       return ERR_PTR(-ENOKEY);
 
  found:
        atomic_inc(&key->usage);
- error:
-       return key;
+       rcu_read_unlock();
+       return make_key_ref(key, possessed);
 
 } /* end __keyring_search_one() */
 
@@ -540,13 +512,14 @@ struct key *find_keyring_by_name(const char *name, key_serial_t bound)
                                    &keyring_name_hash[bucket],
                                    type_data.link
                                    ) {
-                       if (keyring->flags & KEY_FLAG_REVOKED)
+                       if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
                                continue;
 
                        if (strcmp(keyring->description, name) != 0)
                                continue;
 
-                       if (!key_permission(keyring, KEY_SEARCH))
+                       if (key_permission(make_key_ref(keyring, 0),
+                                          KEY_SEARCH) < 0)
                                continue;
 
                        /* found a potential candidate, but we still need to
@@ -579,7 +552,7 @@ struct key *find_keyring_by_name(const char *name, key_serial_t bound)
 static int keyring_detect_cycle(struct key *A, struct key *B)
 {
        struct {
-               struct key *subtree;
+               struct keyring_list *keylist;
                int kix;
        } stack[KEYRING_SEARCH_MAX_DEPTH];
 
@@ -587,20 +560,21 @@ static int keyring_detect_cycle(struct key *A, struct key *B)
        struct key *subtree, *key;
        int sp, kix, ret;
 
+       rcu_read_lock();
+
        ret = -EDEADLK;
        if (A == B)
-               goto error;
+               goto cycle_detected;
 
        subtree = B;
        sp = 0;
 
        /* start processing a new keyring */
  descend:
-       read_lock(&subtree->lock);
-       if (subtree->flags & KEY_FLAG_REVOKED)
+       if (test_bit(KEY_FLAG_REVOKED, &subtree->flags))
                goto not_this_keyring;
 
-       keylist = subtree->payload.subscriptions;
+       keylist = rcu_dereference(subtree->payload.subscriptions);
        if (!keylist)
                goto not_this_keyring;
        kix = 0;
@@ -619,7 +593,7 @@ static int keyring_detect_cycle(struct key *A, struct key *B)
                                goto too_deep;
 
                        /* stack the current position */
-                       stack[sp].subtree = subtree;
+                       stack[sp].keylist = keylist;
                        stack[sp].kix = kix;
                        sp++;
 
@@ -632,13 +606,10 @@ static int keyring_detect_cycle(struct key *A, struct key *B)
        /* the keyring we're looking at was disqualified or didn't contain a
         * matching key */
  not_this_keyring:
-       read_unlock(&subtree->lock);
-
        if (sp > 0) {
                /* resume the checking of a keyring higher up in the tree */
                sp--;
-               subtree = stack[sp].subtree;
-               keylist = subtree->payload.subscriptions;
+               keylist = stack[sp].keylist;
                kix = stack[sp].kix + 1;
                goto ascend;
        }
@@ -646,40 +617,62 @@ static int keyring_detect_cycle(struct key *A, struct key *B)
        ret = 0; /* no cycles detected */
 
  error:
+       rcu_read_unlock();
        return ret;
 
  too_deep:
        ret = -ELOOP;
-       goto error_unwind;
+       goto error;
+
  cycle_detected:
        ret = -EDEADLK;
- error_unwind:
-       read_unlock(&subtree->lock);
-
-       /* unwind the keyring stack */
-       while (sp > 0) {
-               sp--;
-               read_unlock(&stack[sp].subtree->lock);
-       }
-
        goto error;
 
 } /* end keyring_detect_cycle() */
 
 /*****************************************************************************/
 /*
+ * dispose of a keyring list after the RCU grace period
+ */
+static void keyring_link_rcu_disposal(struct rcu_head *rcu)
+{
+       struct keyring_list *klist =
+               container_of(rcu, struct keyring_list, rcu);
+
+       kfree(klist);
+
+} /* end keyring_link_rcu_disposal() */
+
+/*****************************************************************************/
+/*
+ * dispose of a keyring list after the RCU grace period, freeing the unlinked
+ * key
+ */
+static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
+{
+       struct keyring_list *klist =
+               container_of(rcu, struct keyring_list, rcu);
+
+       key_put(klist->keys[klist->delkey]);
+       kfree(klist);
+
+} /* end keyring_unlink_rcu_disposal() */
+
+/*****************************************************************************/
+/*
  * link a key into to a keyring
- * - must be called with the keyring's semaphore held
+ * - must be called with the keyring's semaphore write-locked
+ * - discard already extant link to matching key if there is one
  */
 int __key_link(struct key *keyring, struct key *key)
 {
        struct keyring_list *klist, *nklist;
        unsigned max;
        size_t size;
-       int ret;
+       int loop, ret;
 
        ret = -EKEYREVOKED;
-       if (keyring->flags & KEY_FLAG_REVOKED)
+       if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
                goto error;
 
        ret = -ENOTDIR;
@@ -698,6 +691,46 @@ int __key_link(struct key *keyring, struct key *key)
                        goto error2;
        }
 
+       /* see if there's a matching key we can displace */
+       klist = keyring->payload.subscriptions;
+
+       if (klist && klist->nkeys > 0) {
+               struct key_type *type = key->type;
+
+               for (loop = klist->nkeys - 1; loop >= 0; loop--) {
+                       if (klist->keys[loop]->type == type &&
+                           strcmp(klist->keys[loop]->description,
+                                  key->description) == 0
+                           ) {
+                               /* found a match - replace with new key */
+                               size = sizeof(struct key *) * klist->maxkeys;
+                               size += sizeof(*klist);
+                               BUG_ON(size > PAGE_SIZE);
+
+                               ret = -ENOMEM;
+                               nklist = kmemdup(klist, size, GFP_KERNEL);
+                               if (!nklist)
+                                       goto error2;
+
+                               /* replace matched key */
+                               atomic_inc(&key->usage);
+                               nklist->keys[loop] = key;
+
+                               rcu_assign_pointer(
+                                       keyring->payload.subscriptions,
+                                       nklist);
+
+                               /* dispose of the old keyring list and the
+                                * displaced key */
+                               klist->delkey = loop;
+                               call_rcu(&klist->rcu,
+                                        keyring_unlink_rcu_disposal);
+
+                               goto done;
+                       }
+               }
+       }
+
        /* check that we aren't going to overrun the user's quota */
        ret = key_payload_reserve(keyring,
                                  keyring->datalen + KEYQUOTA_LINK_BYTES);
@@ -710,11 +743,10 @@ int __key_link(struct key *keyring, struct key *key)
                /* there's sufficient slack space to add directly */
                atomic_inc(&key->usage);
 
-               write_lock(&keyring->lock);
-               klist->keys[klist->nkeys++] = key;
-               write_unlock(&keyring->lock);
-
-               ret = 0;
+               klist->keys[klist->nkeys] = key;
+               smp_wmb();
+               klist->nkeys++;
+               smp_wmb();
        }
        else {
                /* grow the key list */
@@ -723,7 +755,9 @@ int __key_link(struct key *keyring, struct key *key)
                        max += klist->maxkeys;
 
                ret = -ENFILE;
-               size = sizeof(*klist) + sizeof(*key) * max;
+               if (max > 65535)
+                       goto error3;
+               size = sizeof(*klist) + sizeof(struct key *) * max;
                if (size > PAGE_SIZE)
                        goto error3;
 
@@ -743,24 +777,23 @@ int __key_link(struct key *keyring, struct key *key)
 
                /* add the key into the new space */
                atomic_inc(&key->usage);
-
-               write_lock(&keyring->lock);
-               keyring->payload.subscriptions = nklist;
                nklist->keys[nklist->nkeys++] = key;
-               write_unlock(&keyring->lock);
 
-               /* dispose of the old keyring list */
-               kfree(klist);
+               rcu_assign_pointer(keyring->payload.subscriptions, nklist);
 
-               ret = 0;
+               /* dispose of the old keyring list */
+               if (klist)
+                       call_rcu(&klist->rcu, keyring_link_rcu_disposal);
        }
 
- error2:
+done:
+       ret = 0;
+error2:
        up_write(&keyring_serialise_link_sem);
- error:
+error:
        return ret;
 
- error3:
+error3:
        /* undo the quota changes */
        key_payload_reserve(keyring,
                            keyring->datalen - KEYQUOTA_LINK_BYTES);
@@ -795,7 +828,7 @@ EXPORT_SYMBOL(key_link);
  */
 int key_unlink(struct key *keyring, struct key *key)
 {
-       struct keyring_list *klist;
+       struct keyring_list *klist, *nklist;
        int loop, ret;
 
        key_check(keyring);
@@ -819,31 +852,46 @@ int key_unlink(struct key *keyring, struct key *key)
        ret = -ENOENT;
        goto error;
 
- key_is_present:
+key_is_present:
+       /* we need to copy the key list for RCU purposes */
+       nklist = kmalloc(sizeof(*klist) +
+                        sizeof(struct key *) * klist->maxkeys,
+                        GFP_KERNEL);
+       if (!nklist)
+               goto nomem;
+       nklist->maxkeys = klist->maxkeys;
+       nklist->nkeys = klist->nkeys - 1;
+
+       if (loop > 0)
+               memcpy(&nklist->keys[0],
+                      &klist->keys[0],
+                      loop * sizeof(struct key *));
+
+       if (loop < nklist->nkeys)
+               memcpy(&nklist->keys[loop],
+                      &klist->keys[loop + 1],
+                      (nklist->nkeys - loop) * sizeof(struct key *));
+
        /* adjust the user's quota */
        key_payload_reserve(keyring,
                            keyring->datalen - KEYQUOTA_LINK_BYTES);
 
-       /* shuffle down the key pointers
-        * - it might be worth shrinking the allocated memory, but that runs
-        *   the risk of ENOMEM as we would have to copy
-        */
-       write_lock(&keyring->lock);
+       rcu_assign_pointer(keyring->payload.subscriptions, nklist);
 
-       klist->nkeys--;
-       if (loop < klist->nkeys)
-               memcpy(&klist->keys[loop],
-                      &klist->keys[loop + 1],
-                      (klist->nkeys - loop) * sizeof(struct key *));
+       up_write(&keyring->sem);
 
-       write_unlock(&keyring->lock);
+       /* schedule for later cleanup */
+       klist->delkey = loop;
+       call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
 
-       up_write(&keyring->sem);
-       key_put(key);
        ret = 0;
 
- error:
+error:
        return ret;
+nomem:
+       ret = -ENOMEM;
+       up_write(&keyring->sem);
+       goto error;
 
 } /* end key_unlink() */
 
@@ -851,13 +899,32 @@ EXPORT_SYMBOL(key_unlink);
 
 /*****************************************************************************/
 /*
+ * dispose of a keyring list after the RCU grace period, releasing the keys it
+ * links to
+ */
+static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
+{
+       struct keyring_list *klist;
+       int loop;
+
+       klist = container_of(rcu, struct keyring_list, rcu);
+
+       for (loop = klist->nkeys - 1; loop >= 0; loop--)
+               key_put(klist->keys[loop]);
+
+       kfree(klist);
+
+} /* end keyring_clear_rcu_disposal() */
+
+/*****************************************************************************/
+/*
  * clear the specified process keyring
  * - implements keyctl(KEYCTL_CLEAR)
  */
 int keyring_clear(struct key *keyring)
 {
        struct keyring_list *klist;
-       int loop, ret;
+       int ret;
 
        ret = -ENOTDIR;
        if (keyring->type == &key_type_keyring) {
@@ -870,20 +937,15 @@ int keyring_clear(struct key *keyring)
                        key_payload_reserve(keyring,
                                            sizeof(struct keyring_list));
 
-                       write_lock(&keyring->lock);
-                       keyring->payload.subscriptions = NULL;
-                       write_unlock(&keyring->lock);
+                       rcu_assign_pointer(keyring->payload.subscriptions,
+                                          NULL);
                }
 
                up_write(&keyring->sem);
 
                /* free the keys after the locks have been dropped */
-               if (klist) {
-                       for (loop = klist->nkeys - 1; loop >= 0; loop--)
-                               key_put(klist->keys[loop]);
-
-                       kfree(klist);
-               }
+               if (klist)
+                       call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
 
                ret = 0;
        }
@@ -893,3 +955,22 @@ int keyring_clear(struct key *keyring)
 } /* end keyring_clear() */
 
 EXPORT_SYMBOL(keyring_clear);
+
+/*****************************************************************************/
+/*
+ * dispose of the links from a revoked keyring
+ * - called with the key sem write-locked
+ */
+static void keyring_revoke(struct key *keyring)
+{
+       struct keyring_list *klist = keyring->payload.subscriptions;
+
+       /* adjust the quota */
+       key_payload_reserve(keyring, 0);
+
+       if (klist) {
+               rcu_assign_pointer(keyring->payload.subscriptions, NULL);
+               call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
+       }
+
+} /* end keyring_revoke() */