]>
Commit | Line | Data |
---|---|---|
0b04990a TC |
1 | /* |
2 | * CDDL HEADER START | |
3 | * | |
4 | * The contents of this file are subject to the terms of the | |
5 | * Common Development and Distribution License (the "License"). | |
6 | * You may not use this file except in compliance with the License. | |
7 | * | |
8 | * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
9 | * or http://www.opensolaris.org/os/licensing. | |
10 | * See the License for the specific language governing permissions | |
11 | * and limitations under the License. | |
12 | * | |
13 | * When distributing Covered Code, include this CDDL HEADER in each | |
14 | * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
15 | * If applicable, add the following below this CDDL HEADER, with the | |
16 | * fields enclosed by brackets "[]" replaced with your own identifying | |
17 | * information: Portions Copyright [yyyy] [name of copyright owner] | |
18 | * | |
19 | * CDDL HEADER END | |
20 | */ | |
21 | /* | |
22 | * Copyright 2008 Sun Microsystems, Inc. All rights reserved. | |
23 | * Use is subject to license terms. | |
24 | */ | |
25 | ||
26 | #include <sys/zfs_context.h> | |
27 | #include <sys/crypto/common.h> | |
28 | #include <sys/crypto/api.h> | |
29 | #include <sys/crypto/impl.h> | |
30 | #include <sys/crypto/sched_impl.h> | |
31 | ||
32 | /* | |
33 | * All event subscribers are put on a list. kcf_notify_list_lock | |
34 | * protects changes to this list. | |
35 | * | |
36 | * The following locking order is maintained in the code - The | |
37 | * global kcf_notify_list_lock followed by the individual lock | |
38 | * in a kcf_ntfy_elem structure (kn_lock). | |
39 | */ | |
40 | kmutex_t ntfy_list_lock; | |
41 | kcondvar_t ntfy_list_cv; /* cv the service thread waits on */ | |
42 | static kcf_ntfy_elem_t *ntfy_list_head; | |
43 | ||
44 | /* | |
45 | * crypto_mech2id() | |
46 | * | |
47 | * Arguments: | |
48 | * . mechname: A null-terminated string identifying the mechanism name. | |
49 | * | |
50 | * Description: | |
51 | * Walks the mechanisms tables, looking for an entry that matches the | |
52 | * mechname. Once it find it, it builds the 64-bit mech_type and returns | |
53 | * it. If there are no hardware or software providers for the mechanism, | |
54 | * but there is an unloaded software provider, this routine will attempt | |
55 | * to load it. | |
56 | * | |
57 | * Context: | |
58 | * Process and interruption. | |
59 | * | |
60 | * Returns: | |
61 | * The unique mechanism identified by 'mechname', if found. | |
62 | * CRYPTO_MECH_INVALID otherwise. | |
63 | */ | |
64 | crypto_mech_type_t | |
18168da7 | 65 | crypto_mech2id(const char *mechname) |
0b04990a TC |
66 | { |
67 | return (crypto_mech2id_common(mechname, B_TRUE)); | |
68 | } | |
69 | ||
70 | /* | |
71 | * We walk the notification list and do the callbacks. | |
72 | */ | |
73 | void | |
74 | kcf_walk_ntfylist(uint32_t event, void *event_arg) | |
75 | { | |
76 | kcf_ntfy_elem_t *nep; | |
77 | int nelem = 0; | |
78 | ||
79 | mutex_enter(&ntfy_list_lock); | |
80 | ||
81 | /* | |
82 | * Count how many clients are on the notification list. We need | |
83 | * this count to ensure that clients which joined the list after we | |
84 | * have started this walk, are not wrongly notified. | |
85 | */ | |
86 | for (nep = ntfy_list_head; nep != NULL; nep = nep->kn_next) | |
87 | nelem++; | |
88 | ||
89 | for (nep = ntfy_list_head; (nep != NULL && nelem); nep = nep->kn_next) { | |
90 | nelem--; | |
91 | ||
92 | /* | |
93 | * Check if this client is interested in the | |
94 | * event. | |
95 | */ | |
96 | if (!(nep->kn_event_mask & event)) | |
97 | continue; | |
98 | ||
99 | mutex_enter(&nep->kn_lock); | |
100 | nep->kn_state = NTFY_RUNNING; | |
101 | mutex_exit(&nep->kn_lock); | |
102 | mutex_exit(&ntfy_list_lock); | |
103 | ||
104 | /* | |
105 | * We invoke the callback routine with no locks held. Another | |
106 | * client could have joined the list meanwhile. This is fine | |
107 | * as we maintain nelem as stated above. The NULL check in the | |
108 | * for loop guards against shrinkage. Also, any callers of | |
109 | * crypto_unnotify_events() at this point cv_wait till kn_state | |
110 | * changes to NTFY_WAITING. Hence, nep is assured to be valid. | |
111 | */ | |
112 | (*nep->kn_func)(event, event_arg); | |
113 | ||
114 | mutex_enter(&nep->kn_lock); | |
115 | nep->kn_state = NTFY_WAITING; | |
116 | cv_broadcast(&nep->kn_cv); | |
117 | mutex_exit(&nep->kn_lock); | |
118 | ||
119 | mutex_enter(&ntfy_list_lock); | |
120 | } | |
121 | ||
122 | mutex_exit(&ntfy_list_lock); | |
123 | } | |
124 | ||
93ce2b4c | 125 | #if defined(_KERNEL) |
0b04990a TC |
126 | EXPORT_SYMBOL(crypto_mech2id); |
127 | #endif |