3 * Copyright (C) 2004-2005, 2008 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <linux/security.h>
17 #include <linux/seq_file.h>
18 #include <linux/err.h>
19 #include <keys/keyring-type.h>
20 #include <linux/uaccess.h>
23 #define rcu_dereference_locked_keyring(keyring) \
24 (rcu_dereference_protected( \
25 (keyring)->payload.subscriptions, \
26 rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
28 #define rcu_deref_link_locked(klist, index, keyring) \
29 (rcu_dereference_protected( \
30 (klist)->keys[index], \
31 rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
33 #define MAX_KEYRING_LINKS \
34 min_t(size_t, USHRT_MAX - 1, \
35 ((PAGE_SIZE - sizeof(struct keyring_list)) / sizeof(struct key *)))
37 #define KEY_LINK_FIXQUOTA 1UL
40 * When plumbing the depths of the key tree, this sets a hard limit
41 * set on how deep we're willing to go.
43 #define KEYRING_SEARCH_MAX_DEPTH 6
46 * We keep all named keyrings in a hash to speed looking them up.
48 #define KEYRING_NAME_HASH_SIZE (1 << 5)
50 static struct list_head keyring_name_hash
[KEYRING_NAME_HASH_SIZE
];
51 static DEFINE_RWLOCK(keyring_name_lock
);
53 static inline unsigned keyring_hash(const char *desc
)
58 bucket
+= (unsigned char)*desc
;
60 return bucket
& (KEYRING_NAME_HASH_SIZE
- 1);
64 * The keyring key type definition. Keyrings are simply keys of this type and
65 * can be treated as ordinary keys in addition to having their own special
68 static int keyring_instantiate(struct key
*keyring
,
69 struct key_preparsed_payload
*prep
);
70 static int keyring_match(const struct key
*keyring
, const void *criterion
);
71 static void keyring_revoke(struct key
*keyring
);
72 static void keyring_destroy(struct key
*keyring
);
73 static void keyring_describe(const struct key
*keyring
, struct seq_file
*m
);
74 static long keyring_read(const struct key
*keyring
,
75 char __user
*buffer
, size_t buflen
);
77 struct key_type key_type_keyring
= {
79 .def_datalen
= sizeof(struct keyring_list
),
80 .instantiate
= keyring_instantiate
,
81 .match
= keyring_match
,
82 .revoke
= keyring_revoke
,
83 .destroy
= keyring_destroy
,
84 .describe
= keyring_describe
,
87 EXPORT_SYMBOL(key_type_keyring
);
90 * Semaphore to serialise link/link calls to prevent two link calls in parallel
91 * introducing a cycle.
93 static DECLARE_RWSEM(keyring_serialise_link_sem
);
96 * Publish the name of a keyring so that it can be found by name (if it has
99 static void keyring_publish_name(struct key
*keyring
)
103 if (keyring
->description
) {
104 bucket
= keyring_hash(keyring
->description
);
106 write_lock(&keyring_name_lock
);
108 if (!keyring_name_hash
[bucket
].next
)
109 INIT_LIST_HEAD(&keyring_name_hash
[bucket
]);
111 list_add_tail(&keyring
->type_data
.link
,
112 &keyring_name_hash
[bucket
]);
114 write_unlock(&keyring_name_lock
);
119 * Initialise a keyring.
121 * Returns 0 on success, -EINVAL if given any data.
123 static int keyring_instantiate(struct key
*keyring
,
124 struct key_preparsed_payload
*prep
)
129 if (prep
->datalen
== 0) {
130 /* make the keyring available by name if it has one */
131 keyring_publish_name(keyring
);
139 * Match keyrings on their name
141 static int keyring_match(const struct key
*keyring
, const void *description
)
143 return keyring
->description
&&
144 strcmp(keyring
->description
, description
) == 0;
148 * Clean up a keyring when it is destroyed. Unpublish its name if it had one
149 * and dispose of its data.
151 * The garbage collector detects the final key_put(), removes the keyring from
152 * the serial number tree and then does RCU synchronisation before coming here,
153 * so we shouldn't need to worry about code poking around here with the RCU
154 * readlock held by this time.
156 static void keyring_destroy(struct key
*keyring
)
158 struct keyring_list
*klist
;
161 if (keyring
->description
) {
162 write_lock(&keyring_name_lock
);
164 if (keyring
->type_data
.link
.next
!= NULL
&&
165 !list_empty(&keyring
->type_data
.link
))
166 list_del(&keyring
->type_data
.link
);
168 write_unlock(&keyring_name_lock
);
171 klist
= rcu_access_pointer(keyring
->payload
.subscriptions
);
173 for (loop
= klist
->nkeys
- 1; loop
>= 0; loop
--)
174 key_put(rcu_access_pointer(klist
->keys
[loop
]));
180 * Describe a keyring for /proc.
182 static void keyring_describe(const struct key
*keyring
, struct seq_file
*m
)
184 struct keyring_list
*klist
;
186 if (keyring
->description
)
187 seq_puts(m
, keyring
->description
);
189 seq_puts(m
, "[anon]");
191 if (key_is_instantiated(keyring
)) {
193 klist
= rcu_dereference(keyring
->payload
.subscriptions
);
195 seq_printf(m
, ": %u/%u", klist
->nkeys
, klist
->maxkeys
);
197 seq_puts(m
, ": empty");
203 * Read a list of key IDs from the keyring's contents in binary form
205 * The keyring's semaphore is read-locked by the caller.
207 static long keyring_read(const struct key
*keyring
,
208 char __user
*buffer
, size_t buflen
)
210 struct keyring_list
*klist
;
216 klist
= rcu_dereference_locked_keyring(keyring
);
218 /* calculate how much data we could return */
219 qty
= klist
->nkeys
* sizeof(key_serial_t
);
221 if (buffer
&& buflen
> 0) {
225 /* copy the IDs of the subscribed keys into the
229 for (loop
= 0; loop
< klist
->nkeys
; loop
++) {
230 key
= rcu_deref_link_locked(klist
, loop
,
233 tmp
= sizeof(key_serial_t
);
237 if (copy_to_user(buffer
,
257 * Allocate a keyring and link into the destination keyring.
259 struct key
*keyring_alloc(const char *description
, kuid_t uid
, kgid_t gid
,
260 const struct cred
*cred
, key_perm_t perm
,
261 unsigned long flags
, struct key
*dest
)
266 keyring
= key_alloc(&key_type_keyring
, description
,
267 uid
, gid
, cred
, perm
, flags
);
268 if (!IS_ERR(keyring
)) {
269 ret
= key_instantiate_and_link(keyring
, NULL
, 0, dest
, NULL
);
272 keyring
= ERR_PTR(ret
);
278 EXPORT_SYMBOL(keyring_alloc
);
281 * keyring_search_aux - Search a keyring tree for a key matching some criteria
282 * @keyring_ref: A pointer to the keyring with possession indicator.
283 * @cred: The credentials to use for permissions checks.
284 * @type: The type of key to search for.
285 * @description: Parameter for @match.
286 * @match: Function to rule on whether or not a key is the one required.
287 * @no_state_check: Don't check if a matching key is bad
289 * Search the supplied keyring tree for a key that matches the criteria given.
290 * The root keyring and any linked keyrings must grant Search permission to the
291 * caller to be searchable and keys can only be found if they too grant Search
292 * to the caller. The possession flag on the root keyring pointer controls use
293 * of the possessor bits in permissions checking of the entire tree. In
294 * addition, the LSM gets to forbid keyring searches and key matches.
296 * The search is performed as a breadth-then-depth search up to the prescribed
297 * limit (KEYRING_SEARCH_MAX_DEPTH).
299 * Keys are matched to the type provided and are then filtered by the match
300 * function, which is given the description to use in any way it sees fit. The
301 * match function may use any attributes of a key that it wishes to to
302 * determine the match. Normally the match function from the key type would be
305 * RCU is used to prevent the keyring key lists from disappearing without the
306 * need to take lots of locks.
308 * Returns a pointer to the found key and increments the key usage count if
309 * successful; -EAGAIN if no matching keys were found, or if expired or revoked
310 * keys were found; -ENOKEY if only negative keys were found; -ENOTDIR if the
311 * specified keyring wasn't a keyring.
313 * In the case of a successful return, the possession attribute from
314 * @keyring_ref is propagated to the returned key reference.
316 key_ref_t
keyring_search_aux(key_ref_t keyring_ref
,
317 const struct cred
*cred
,
318 struct key_type
*type
,
319 const void *description
,
320 key_match_func_t match
,
324 /* Need a separate keylist pointer for RCU purposes */
326 struct keyring_list
*keylist
;
328 } stack
[KEYRING_SEARCH_MAX_DEPTH
];
330 struct keyring_list
*keylist
;
332 unsigned long possessed
, kflags
;
333 struct key
*keyring
, *key
;
338 keyring
= key_ref_to_ptr(keyring_ref
);
339 possessed
= is_key_possessed(keyring_ref
);
342 /* top keyring must have search permission to begin the search */
343 err
= key_task_permission(keyring_ref
, cred
, KEY_SEARCH
);
345 key_ref
= ERR_PTR(err
);
349 key_ref
= ERR_PTR(-ENOTDIR
);
350 if (keyring
->type
!= &key_type_keyring
)
355 now
= current_kernel_time();
359 /* firstly we should check to see if this top-level keyring is what we
361 key_ref
= ERR_PTR(-EAGAIN
);
362 kflags
= keyring
->flags
;
363 if (keyring
->type
== type
&& match(keyring
, description
)) {
368 /* check it isn't negative and hasn't expired or been
370 if (kflags
& (1 << KEY_FLAG_REVOKED
))
372 if (key
->expiry
&& now
.tv_sec
>= key
->expiry
)
374 key_ref
= ERR_PTR(key
->type_data
.reject_error
);
375 if (kflags
& (1 << KEY_FLAG_NEGATIVE
))
380 /* otherwise, the top keyring must not be revoked, expired, or
381 * negatively instantiated if we are to search it */
382 key_ref
= ERR_PTR(-EAGAIN
);
383 if (kflags
& ((1 << KEY_FLAG_INVALIDATED
) |
384 (1 << KEY_FLAG_REVOKED
) |
385 (1 << KEY_FLAG_NEGATIVE
)) ||
386 (keyring
->expiry
&& now
.tv_sec
>= keyring
->expiry
))
389 /* start processing a new keyring */
391 kflags
= keyring
->flags
;
392 if (kflags
& ((1 << KEY_FLAG_INVALIDATED
) |
393 (1 << KEY_FLAG_REVOKED
)))
394 goto not_this_keyring
;
396 keylist
= rcu_dereference(keyring
->payload
.subscriptions
);
398 goto not_this_keyring
;
400 /* iterate through the keys in this keyring first */
401 nkeys
= keylist
->nkeys
;
403 for (kix
= 0; kix
< nkeys
; kix
++) {
404 key
= rcu_dereference(keylist
->keys
[kix
]);
407 /* ignore keys not of this type */
408 if (key
->type
!= type
)
411 /* skip invalidated, revoked and expired keys */
412 if (!no_state_check
) {
413 if (kflags
& ((1 << KEY_FLAG_INVALIDATED
) |
414 (1 << KEY_FLAG_REVOKED
)))
417 if (key
->expiry
&& now
.tv_sec
>= key
->expiry
)
421 /* keys that don't match */
422 if (!match(key
, description
))
425 /* key must have search permissions */
426 if (key_task_permission(make_key_ref(key
, possessed
),
427 cred
, KEY_SEARCH
) < 0)
433 /* we set a different error code if we pass a negative key */
434 if (kflags
& (1 << KEY_FLAG_NEGATIVE
)) {
435 err
= key
->type_data
.reject_error
;
442 /* search through the keyrings nested in this one */
445 nkeys
= keylist
->nkeys
;
447 for (; kix
< nkeys
; kix
++) {
448 key
= rcu_dereference(keylist
->keys
[kix
]);
449 if (key
->type
!= &key_type_keyring
)
452 /* recursively search nested keyrings
453 * - only search keyrings for which we have search permission
455 if (sp
>= KEYRING_SEARCH_MAX_DEPTH
)
458 if (key_task_permission(make_key_ref(key
, possessed
),
459 cred
, KEY_SEARCH
) < 0)
462 /* stack the current position */
463 stack
[sp
].keyring
= keyring
;
464 stack
[sp
].keylist
= keylist
;
468 /* begin again with the new keyring */
473 /* the keyring we're looking at was disqualified or didn't contain a
477 /* resume the processing of a keyring higher up in the tree */
479 keyring
= stack
[sp
].keyring
;
480 keylist
= stack
[sp
].keylist
;
481 kix
= stack
[sp
].kix
+ 1;
485 key_ref
= ERR_PTR(err
);
488 /* we found a viable match */
490 atomic_inc(&key
->usage
);
491 key
->last_used_at
= now
.tv_sec
;
492 keyring
->last_used_at
= now
.tv_sec
;
494 stack
[--sp
].keyring
->last_used_at
= now
.tv_sec
;
496 key_ref
= make_key_ref(key
, possessed
);
504 * keyring_search - Search the supplied keyring tree for a matching key
505 * @keyring: The root of the keyring tree to be searched.
506 * @type: The type of keyring we want to find.
507 * @description: The name of the keyring we want to find.
509 * As keyring_search_aux() above, but using the current task's credentials and
510 * type's default matching function.
512 key_ref_t
keyring_search(key_ref_t keyring
,
513 struct key_type
*type
,
514 const char *description
)
517 return ERR_PTR(-ENOKEY
);
519 return keyring_search_aux(keyring
, current
->cred
,
520 type
, description
, type
->match
, false);
522 EXPORT_SYMBOL(keyring_search
);
525 * Search the given keyring only (no recursion).
527 * The caller must guarantee that the keyring is a keyring and that the
528 * permission is granted to search the keyring as no check is made here.
530 * RCU is used to make it unnecessary to lock the keyring key list here.
532 * Returns a pointer to the found key with usage count incremented if
533 * successful and returns -ENOKEY if not found. Revoked keys and keys not
534 * providing the requested permission are skipped over.
536 * If successful, the possession indicator is propagated from the keyring ref
537 * to the returned key reference.
539 key_ref_t
__keyring_search_one(key_ref_t keyring_ref
,
540 const struct key_type
*ktype
,
541 const char *description
,
544 struct keyring_list
*klist
;
545 unsigned long possessed
;
546 struct key
*keyring
, *key
;
549 keyring
= key_ref_to_ptr(keyring_ref
);
550 possessed
= is_key_possessed(keyring_ref
);
554 klist
= rcu_dereference(keyring
->payload
.subscriptions
);
556 nkeys
= klist
->nkeys
;
558 for (loop
= 0; loop
< nkeys
; loop
++) {
559 key
= rcu_dereference(klist
->keys
[loop
]);
560 if (key
->type
== ktype
&&
561 (!key
->type
->match
||
562 key
->type
->match(key
, description
)) &&
563 key_permission(make_key_ref(key
, possessed
),
565 !(key
->flags
& ((1 << KEY_FLAG_INVALIDATED
) |
566 (1 << KEY_FLAG_REVOKED
)))
573 return ERR_PTR(-ENOKEY
);
576 atomic_inc(&key
->usage
);
577 keyring
->last_used_at
= key
->last_used_at
=
578 current_kernel_time().tv_sec
;
580 return make_key_ref(key
, possessed
);
584 * Find a keyring with the specified name.
586 * Only keyrings that have nonzero refcount, are not revoked, and are owned by a
587 * user in the current user namespace are considered. If @uid_keyring is %true,
588 * the keyring additionally must have been allocated as a user or user session
589 * keyring; otherwise, it must grant Search permission directly to the caller.
591 * Returns a pointer to the keyring with the keyring's refcount having being
592 * incremented on success. -ENOKEY is returned if a key could not be found.
594 struct key
*find_keyring_by_name(const char *name
, bool uid_keyring
)
600 return ERR_PTR(-EINVAL
);
602 bucket
= keyring_hash(name
);
604 read_lock(&keyring_name_lock
);
606 if (keyring_name_hash
[bucket
].next
) {
607 /* search this hash bucket for a keyring with a matching name
608 * that's readable and that hasn't been revoked */
609 list_for_each_entry(keyring
,
610 &keyring_name_hash
[bucket
],
613 if (!kuid_has_mapping(current_user_ns(), keyring
->user
->uid
))
616 if (test_bit(KEY_FLAG_REVOKED
, &keyring
->flags
))
619 if (strcmp(keyring
->description
, name
) != 0)
623 if (!test_bit(KEY_FLAG_UID_KEYRING
,
627 if (key_permission(make_key_ref(keyring
, 0),
632 /* we've got a match but we might end up racing with
633 * key_cleanup() if the keyring is currently 'dead'
634 * (ie. it has a zero usage count) */
635 if (!atomic_inc_not_zero(&keyring
->usage
))
637 keyring
->last_used_at
= current_kernel_time().tv_sec
;
642 keyring
= ERR_PTR(-ENOKEY
);
644 read_unlock(&keyring_name_lock
);
649 * See if a cycle will will be created by inserting acyclic tree B in acyclic
650 * tree A at the topmost level (ie: as a direct child of A).
652 * Since we are adding B to A at the top level, checking for cycles should just
653 * be a matter of seeing if node A is somewhere in tree B.
655 static int keyring_detect_cycle(struct key
*A
, struct key
*B
)
658 struct keyring_list
*keylist
;
660 } stack
[KEYRING_SEARCH_MAX_DEPTH
];
662 struct keyring_list
*keylist
;
663 struct key
*subtree
, *key
;
664 int sp
, nkeys
, kix
, ret
;
675 /* start processing a new keyring */
677 if (test_bit(KEY_FLAG_REVOKED
, &subtree
->flags
))
678 goto not_this_keyring
;
680 keylist
= rcu_dereference(subtree
->payload
.subscriptions
);
682 goto not_this_keyring
;
686 /* iterate through the remaining keys in this keyring */
687 nkeys
= keylist
->nkeys
;
689 for (; kix
< nkeys
; kix
++) {
690 key
= rcu_dereference(keylist
->keys
[kix
]);
695 /* recursively check nested keyrings */
696 if (key
->type
== &key_type_keyring
) {
697 if (sp
>= KEYRING_SEARCH_MAX_DEPTH
)
700 /* stack the current position */
701 stack
[sp
].keylist
= keylist
;
705 /* begin again with the new keyring */
711 /* the keyring we're looking at was disqualified or didn't contain a
715 /* resume the checking of a keyring higher up in the tree */
717 keylist
= stack
[sp
].keylist
;
718 kix
= stack
[sp
].kix
+ 1;
722 ret
= 0; /* no cycles detected */
738 * Dispose of a keyring list after the RCU grace period, freeing the unlinked
741 static void keyring_unlink_rcu_disposal(struct rcu_head
*rcu
)
743 struct keyring_list
*klist
=
744 container_of(rcu
, struct keyring_list
, rcu
);
746 if (klist
->delkey
!= USHRT_MAX
)
747 key_put(rcu_access_pointer(klist
->keys
[klist
->delkey
]));
752 * Preallocate memory so that a key can be linked into to a keyring.
754 int __key_link_begin(struct key
*keyring
, const struct key_type
*type
,
755 const char *description
, unsigned long *_prealloc
)
756 __acquires(&keyring
->sem
)
757 __acquires(&keyring_serialise_link_sem
)
759 struct keyring_list
*klist
, *nklist
;
760 unsigned long prealloc
;
766 kenter("%d,%s,%s,", key_serial(keyring
), type
->name
, description
);
768 if (keyring
->type
!= &key_type_keyring
)
771 down_write(&keyring
->sem
);
774 if (test_bit(KEY_FLAG_REVOKED
, &keyring
->flags
))
777 /* serialise link/link calls to prevent parallel calls causing a cycle
778 * when linking two keyring in opposite orders */
779 if (type
== &key_type_keyring
)
780 down_write(&keyring_serialise_link_sem
);
782 klist
= rcu_dereference_locked_keyring(keyring
);
784 /* see if there's a matching key we can displace */
786 if (klist
&& klist
->nkeys
> 0) {
787 lowest_lru
= TIME_T_MAX
;
788 for (loop
= klist
->nkeys
- 1; loop
>= 0; loop
--) {
789 struct key
*key
= rcu_deref_link_locked(klist
, loop
,
791 if (key
->type
== type
&&
792 strcmp(key
->description
, description
) == 0) {
793 /* Found a match - we'll replace the link with
794 * one to the new key. We record the slot
797 klist
->delkey
= loop
;
801 if (key
->last_used_at
< lowest_lru
) {
802 lowest_lru
= key
->last_used_at
;
808 /* If the keyring is full then do an LRU discard */
810 klist
->nkeys
== klist
->maxkeys
&&
811 klist
->maxkeys
>= MAX_KEYRING_LINKS
) {
812 kdebug("LRU discard %d\n", lru
);
818 /* check that we aren't going to overrun the user's quota */
819 ret
= key_payload_reserve(keyring
,
820 keyring
->datalen
+ KEYQUOTA_LINK_BYTES
);
824 if (klist
&& klist
->nkeys
< klist
->maxkeys
) {
825 /* there's sufficient slack space to append directly */
826 klist
->delkey
= klist
->nkeys
;
827 prealloc
= KEY_LINK_FIXQUOTA
;
829 /* grow the key list */
832 max
+= klist
->maxkeys
;
833 if (max
> MAX_KEYRING_LINKS
)
834 max
= MAX_KEYRING_LINKS
;
835 BUG_ON(max
<= klist
->maxkeys
);
838 size
= sizeof(*klist
) + sizeof(struct key
*) * max
;
841 nklist
= kmalloc(size
, GFP_KERNEL
);
845 nklist
->maxkeys
= max
;
847 memcpy(nklist
->keys
, klist
->keys
,
848 sizeof(struct key
*) * klist
->nkeys
);
849 nklist
->delkey
= klist
->nkeys
;
850 nklist
->nkeys
= klist
->nkeys
+ 1;
851 klist
->delkey
= USHRT_MAX
;
857 /* add the key into the new space */
858 RCU_INIT_POINTER(nklist
->keys
[nklist
->delkey
], NULL
);
859 prealloc
= (unsigned long)nklist
| KEY_LINK_FIXQUOTA
;
863 *_prealloc
= prealloc
;
868 /* undo the quota changes */
869 key_payload_reserve(keyring
,
870 keyring
->datalen
- KEYQUOTA_LINK_BYTES
);
872 if (type
== &key_type_keyring
)
873 up_write(&keyring_serialise_link_sem
);
875 up_write(&keyring
->sem
);
876 kleave(" = %d", ret
);
881 * Check already instantiated keys aren't going to be a problem.
883 * The caller must have called __key_link_begin(). Don't need to call this for
884 * keys that were created since __key_link_begin() was called.
886 int __key_link_check_live_key(struct key
*keyring
, struct key
*key
)
888 if (key
->type
== &key_type_keyring
)
889 /* check that we aren't going to create a cycle by linking one
890 * keyring to another */
891 return keyring_detect_cycle(keyring
, key
);
896 * Link a key into to a keyring.
898 * Must be called with __key_link_begin() having being called. Discards any
899 * already extant link to matching key if there is one, so that each keyring
900 * holds at most one link to any given key of a particular type+description
903 void __key_link(struct key
*keyring
, struct key
*key
,
904 unsigned long *_prealloc
)
906 struct keyring_list
*klist
, *nklist
;
909 nklist
= (struct keyring_list
*)(*_prealloc
& ~KEY_LINK_FIXQUOTA
);
912 kenter("%d,%d,%p", keyring
->serial
, key
->serial
, nklist
);
914 klist
= rcu_dereference_locked_keyring(keyring
);
916 atomic_inc(&key
->usage
);
917 keyring
->last_used_at
= key
->last_used_at
=
918 current_kernel_time().tv_sec
;
920 /* there's a matching key we can displace or an empty slot in a newly
921 * allocated list we can fill */
923 kdebug("reissue %hu/%hu/%hu",
924 nklist
->delkey
, nklist
->nkeys
, nklist
->maxkeys
);
926 RCU_INIT_POINTER(nklist
->keys
[nklist
->delkey
], key
);
928 rcu_assign_pointer(keyring
->payload
.subscriptions
, nklist
);
930 /* dispose of the old keyring list and, if there was one, the
933 kdebug("dispose %hu/%hu/%hu",
934 klist
->delkey
, klist
->nkeys
, klist
->maxkeys
);
935 call_rcu(&klist
->rcu
, keyring_unlink_rcu_disposal
);
937 } else if (klist
->delkey
< klist
->nkeys
) {
938 kdebug("replace %hu/%hu/%hu",
939 klist
->delkey
, klist
->nkeys
, klist
->maxkeys
);
941 discard
= rcu_dereference_protected(
942 klist
->keys
[klist
->delkey
],
943 rwsem_is_locked(&keyring
->sem
));
944 rcu_assign_pointer(klist
->keys
[klist
->delkey
], key
);
945 /* The garbage collector will take care of RCU
949 /* there's sufficient slack space to append directly */
950 kdebug("append %hu/%hu/%hu",
951 klist
->delkey
, klist
->nkeys
, klist
->maxkeys
);
953 RCU_INIT_POINTER(klist
->keys
[klist
->delkey
], key
);
960 * Finish linking a key into to a keyring.
962 * Must be called with __key_link_begin() having being called.
964 void __key_link_end(struct key
*keyring
, struct key_type
*type
,
965 unsigned long prealloc
)
966 __releases(&keyring
->sem
)
967 __releases(&keyring_serialise_link_sem
)
969 BUG_ON(type
== NULL
);
970 BUG_ON(type
->name
== NULL
);
971 kenter("%d,%s,%lx", keyring
->serial
, type
->name
, prealloc
);
973 if (type
== &key_type_keyring
)
974 up_write(&keyring_serialise_link_sem
);
977 if (prealloc
& KEY_LINK_FIXQUOTA
)
978 key_payload_reserve(keyring
,
980 KEYQUOTA_LINK_BYTES
);
981 kfree((struct keyring_list
*)(prealloc
& ~KEY_LINK_FIXQUOTA
));
983 up_write(&keyring
->sem
);
987 * key_link - Link a key to a keyring
988 * @keyring: The keyring to make the link in.
989 * @key: The key to link to.
991 * Make a link in a keyring to a key, such that the keyring holds a reference
992 * on that key and the key can potentially be found by searching that keyring.
994 * This function will write-lock the keyring's semaphore and will consume some
995 * of the user's key data quota to hold the link.
997 * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring,
998 * -EKEYREVOKED if the keyring has been revoked, -ENFILE if the keyring is
999 * full, -EDQUOT if there is insufficient key data quota remaining to add
1000 * another link or -ENOMEM if there's insufficient memory.
1002 * It is assumed that the caller has checked that it is permitted for a link to
1003 * be made (the keyring should have Write permission and the key Link
1006 int key_link(struct key
*keyring
, struct key
*key
)
1008 unsigned long prealloc
;
1014 ret
= __key_link_begin(keyring
, key
->type
, key
->description
, &prealloc
);
1016 ret
= __key_link_check_live_key(keyring
, key
);
1018 __key_link(keyring
, key
, &prealloc
);
1019 __key_link_end(keyring
, key
->type
, prealloc
);
1024 EXPORT_SYMBOL(key_link
);
1027 * key_unlink - Unlink the first link to a key from a keyring.
1028 * @keyring: The keyring to remove the link from.
1029 * @key: The key the link is to.
1031 * Remove a link from a keyring to a key.
1033 * This function will write-lock the keyring's semaphore.
1035 * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring, -ENOENT if
1036 * the key isn't linked to by the keyring or -ENOMEM if there's insufficient
1039 * It is assumed that the caller has checked that it is permitted for a link to
1040 * be removed (the keyring should have Write permission; no permissions are
1041 * required on the key).
1043 int key_unlink(struct key
*keyring
, struct key
*key
)
1045 struct keyring_list
*klist
, *nklist
;
1052 if (keyring
->type
!= &key_type_keyring
)
1055 down_write(&keyring
->sem
);
1057 klist
= rcu_dereference_locked_keyring(keyring
);
1059 /* search the keyring for the key */
1060 for (loop
= 0; loop
< klist
->nkeys
; loop
++)
1061 if (rcu_access_pointer(klist
->keys
[loop
]) == key
)
1062 goto key_is_present
;
1065 up_write(&keyring
->sem
);
1070 /* we need to copy the key list for RCU purposes */
1071 nklist
= kmalloc(sizeof(*klist
) +
1072 sizeof(struct key
*) * klist
->maxkeys
,
1076 nklist
->maxkeys
= klist
->maxkeys
;
1077 nklist
->nkeys
= klist
->nkeys
- 1;
1080 memcpy(&nklist
->keys
[0],
1082 loop
* sizeof(struct key
*));
1084 if (loop
< nklist
->nkeys
)
1085 memcpy(&nklist
->keys
[loop
],
1086 &klist
->keys
[loop
+ 1],
1087 (nklist
->nkeys
- loop
) * sizeof(struct key
*));
1089 /* adjust the user's quota */
1090 key_payload_reserve(keyring
,
1091 keyring
->datalen
- KEYQUOTA_LINK_BYTES
);
1093 rcu_assign_pointer(keyring
->payload
.subscriptions
, nklist
);
1095 up_write(&keyring
->sem
);
1097 /* schedule for later cleanup */
1098 klist
->delkey
= loop
;
1099 call_rcu(&klist
->rcu
, keyring_unlink_rcu_disposal
);
1107 up_write(&keyring
->sem
);
1110 EXPORT_SYMBOL(key_unlink
);
1113 * Dispose of a keyring list after the RCU grace period, releasing the keys it
1116 static void keyring_clear_rcu_disposal(struct rcu_head
*rcu
)
1118 struct keyring_list
*klist
;
1121 klist
= container_of(rcu
, struct keyring_list
, rcu
);
1123 for (loop
= klist
->nkeys
- 1; loop
>= 0; loop
--)
1124 key_put(rcu_access_pointer(klist
->keys
[loop
]));
1130 * keyring_clear - Clear a keyring
1131 * @keyring: The keyring to clear.
1133 * Clear the contents of the specified keyring.
1135 * Returns 0 if successful or -ENOTDIR if the keyring isn't a keyring.
1137 int keyring_clear(struct key
*keyring
)
1139 struct keyring_list
*klist
;
1143 if (keyring
->type
== &key_type_keyring
) {
1144 /* detach the pointer block with the locks held */
1145 down_write(&keyring
->sem
);
1147 klist
= rcu_dereference_locked_keyring(keyring
);
1149 /* adjust the quota */
1150 key_payload_reserve(keyring
,
1151 sizeof(struct keyring_list
));
1153 rcu_assign_pointer(keyring
->payload
.subscriptions
,
1157 up_write(&keyring
->sem
);
1159 /* free the keys after the locks have been dropped */
1161 call_rcu(&klist
->rcu
, keyring_clear_rcu_disposal
);
1168 EXPORT_SYMBOL(keyring_clear
);
1171 * Dispose of the links from a revoked keyring.
1173 * This is called with the key sem write-locked.
1175 static void keyring_revoke(struct key
*keyring
)
1177 struct keyring_list
*klist
;
1179 klist
= rcu_dereference_locked_keyring(keyring
);
1181 /* adjust the quota */
1182 key_payload_reserve(keyring
, 0);
1185 rcu_assign_pointer(keyring
->payload
.subscriptions
, NULL
);
1186 call_rcu(&klist
->rcu
, keyring_clear_rcu_disposal
);
1191 * Collect garbage from the contents of a keyring, replacing the old list with
1192 * a new one with the pointers all shuffled down.
1194 * Dead keys are classed as oned that are flagged as being dead or are revoked,
1195 * expired or negative keys that were revoked or expired before the specified
1198 void keyring_gc(struct key
*keyring
, time_t limit
)
1200 struct keyring_list
*klist
, *new;
1202 int loop
, keep
, max
;
1204 kenter("{%x,%s}", key_serial(keyring
), keyring
->description
);
1206 down_write(&keyring
->sem
);
1208 klist
= rcu_dereference_locked_keyring(keyring
);
1212 /* work out how many subscriptions we're keeping */
1214 for (loop
= klist
->nkeys
- 1; loop
>= 0; loop
--)
1215 if (!key_is_dead(rcu_deref_link_locked(klist
, loop
, keyring
),
1219 if (keep
== klist
->nkeys
)
1222 /* allocate a new keyring payload */
1223 max
= roundup(keep
, 4);
1224 new = kmalloc(sizeof(struct keyring_list
) + max
* sizeof(struct key
*),
1232 /* install the live keys
1233 * - must take care as expired keys may be updated back to life
1236 for (loop
= klist
->nkeys
- 1; loop
>= 0; loop
--) {
1237 key
= rcu_deref_link_locked(klist
, loop
, keyring
);
1238 if (!key_is_dead(key
, limit
)) {
1241 RCU_INIT_POINTER(new->keys
[keep
++], key_get(key
));
1246 /* adjust the quota */
1247 key_payload_reserve(keyring
,
1248 sizeof(struct keyring_list
) +
1249 KEYQUOTA_LINK_BYTES
* keep
);
1252 rcu_assign_pointer(keyring
->payload
.subscriptions
, NULL
);
1255 rcu_assign_pointer(keyring
->payload
.subscriptions
, new);
1258 up_write(&keyring
->sem
);
1260 call_rcu(&klist
->rcu
, keyring_clear_rcu_disposal
);
1266 keyring_clear_rcu_disposal(&new->rcu
);
1267 up_write(&keyring
->sem
);
1268 kleave(" [discard]");
1272 up_write(&keyring
->sem
);
1273 kleave(" [no dead]");
1277 up_write(&keyring
->sem
);
1278 kleave(" [no_klist]");
1282 up_write(&keyring
->sem
);