1 /* $NetBSD: dm_target.c,v 1.12 2010/01/04 00:14:41 haad Exp $ */
2
3 /*
4 * Copyright (c) 2010-2011 Alex Hornung <alex@alexhornung.com>
5 * Copyright (c) 2008 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Adam Hamsik.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code Must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/param.h>
34 #include <sys/malloc.h>
35 #include <sys/module.h>
36 #include <sys/linker.h>
37 #include <cpu/atomic.h>
38 #include <dev/disk/dm/dm.h>
39 #include <dev/disk/dm/netbsd-dm.h>
40
41 static dm_target_t *dm_target_lookup_name(const char *);
42
43 static TAILQ_HEAD(, dm_target) dm_target_list;
44
45 static struct lock dm_target_mutex;
46
47 void
dm_target_busy(dm_target_t * target)48 dm_target_busy(dm_target_t *target)
49 {
50 atomic_add_int(&target->ref_cnt, 1);
51 }
52
53 /*
54 * Release reference counter on target.
55 */
56 void
dm_target_unbusy(dm_target_t * target)57 dm_target_unbusy(dm_target_t *target)
58 {
59 KKASSERT(target->ref_cnt > 0);
60 atomic_subtract_int(&target->ref_cnt, 1);
61 }
62
63 /*
64 * Try to autoload the module for the requested target.
65 */
66 dm_target_t *
dm_target_autoload(const char * dm_target_name)67 dm_target_autoload(const char *dm_target_name)
68 {
69 char mod_name[128];
70 dm_target_t *dmt;
71 linker_file_t linker_file;
72 int error;
73
74 ksnprintf(mod_name, sizeof(mod_name), "dm_target_%s", dm_target_name);
75 error = linker_reference_module(mod_name, NULL, &linker_file);
76 if (error != 0) {
77 kprintf("dm: could not autoload module for target %s\n",
78 dm_target_name);
79 return NULL;
80 }
81
82 dmt = dm_target_lookup(dm_target_name);
83 if (dmt == NULL) {
84 linker_release_module(NULL, NULL, linker_file);
85 return NULL;
86 }
87
88 /* XXX: extra-big hack to allow users to kldunload the module */
89 linker_file->userrefs = 1;
90
91 return dmt;
92 }
93
94 /*
95 * Lookup for target in global target list.
96 */
97 dm_target_t *
dm_target_lookup(const char * dm_target_name)98 dm_target_lookup(const char *dm_target_name)
99 {
100 dm_target_t *dmt;
101
102 dmt = NULL;
103
104 if (dm_target_name == NULL)
105 return NULL;
106
107 lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
108
109 dmt = dm_target_lookup_name(dm_target_name);
110 if (dmt != NULL)
111 dm_target_busy(dmt);
112
113 lockmgr(&dm_target_mutex, LK_RELEASE);
114
115 return dmt;
116 }
117
118 /*
119 * Search for name in TAILQ and return apropriate pointer.
120 */
121 static dm_target_t *
dm_target_lookup_name(const char * dm_target_name)122 dm_target_lookup_name(const char *dm_target_name)
123 {
124 dm_target_t *dm_target;
125
126 TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) {
127 if (strcmp(dm_target_name, dm_target->name) == 0)
128 return dm_target;
129 }
130
131 return NULL;
132 }
133
134 /*
135 * Insert new target struct into the TAILQ.
136 * dm_target contains name, version, function pointer to specific target
137 * functions.
138 */
139 int
dm_target_insert(dm_target_t * dm_target)140 dm_target_insert(dm_target_t *dm_target)
141 {
142 dm_target_t *dmt;
143
144 if (dm_target->strategy == NULL) {
145 kprintf("dm: %s missing strategy\n", dm_target->name);
146 return EINVAL;
147 }
148
149 lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
150
151 dmt = dm_target_lookup_name(dm_target->name);
152 if (dmt != NULL) {
153 kprintf("uhoh, target_insert EEXIST\n");
154 lockmgr(&dm_target_mutex, LK_RELEASE);
155 return EEXIST;
156 }
157 TAILQ_INSERT_TAIL(&dm_target_list, dm_target, dm_target_next);
158
159 lockmgr(&dm_target_mutex, LK_RELEASE);
160
161 return 0;
162 }
163
164 /*
165 * Remove target from TAILQ, target is selected with it's name.
166 */
167 int
dm_target_remove(char * dm_target_name)168 dm_target_remove(char *dm_target_name)
169 {
170 dm_target_t *dmt;
171
172 KKASSERT(dm_target_name != NULL);
173
174 lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
175
176 dmt = dm_target_lookup_name(dm_target_name);
177 if (dmt == NULL) {
178 lockmgr(&dm_target_mutex, LK_RELEASE);
179 return ENOENT;
180 }
181 if (dmt->ref_cnt > 0) {
182 lockmgr(&dm_target_mutex, LK_RELEASE);
183 return EBUSY;
184 }
185 TAILQ_REMOVE(&dm_target_list, dmt, dm_target_next);
186
187 lockmgr(&dm_target_mutex, LK_RELEASE);
188
189 dm_target_free(dmt);
190
191 return 0;
192 }
193
194 /*
195 * Allocate new target entry.
196 */
197 dm_target_t *
dm_target_alloc(const char * name)198 dm_target_alloc(const char *name)
199 {
200 dm_target_t *dmt;
201
202 dmt = kmalloc(sizeof(*dmt), M_DM, M_WAITOK | M_ZERO);
203 if (dmt == NULL)
204 return NULL;
205
206 if (name)
207 strlcpy(dmt->name, name, sizeof(dmt->name));
208
209 return dmt;
210 }
211
212 int
dm_target_free(dm_target_t * dmt)213 dm_target_free(dm_target_t *dmt)
214 {
215 KKASSERT(dmt != NULL);
216
217 kfree(dmt, M_DM);
218
219 return 0;
220 }
221
222 /*
223 * Return prop_array of dm_target dictionaries.
224 */
225 prop_array_t
dm_target_prop_list(void)226 dm_target_prop_list(void)
227 {
228 prop_array_t target_array, ver;
229 prop_dictionary_t target_dict;
230 dm_target_t *dm_target;
231
232 size_t i;
233
234 target_array = prop_array_create();
235
236 lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
237
238 TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) {
239
240 target_dict = prop_dictionary_create();
241 ver = prop_array_create();
242 prop_dictionary_set_cstring(target_dict, DM_TARGETS_NAME,
243 dm_target->name);
244
245 for (i = 0; i < 3; i++)
246 prop_array_add_uint32(ver, dm_target->version[i]);
247
248 prop_dictionary_set(target_dict, DM_TARGETS_VERSION, ver);
249 prop_array_add(target_array, target_dict);
250
251 prop_object_release(ver);
252 prop_object_release(target_dict);
253 }
254
255 lockmgr(&dm_target_mutex, LK_RELEASE);
256
257 return target_array;
258 }
259
260 /*
261 * Initialize dm_target subsystem.
262 */
263 int
dm_target_init(void)264 dm_target_init(void)
265 {
266 TAILQ_INIT(&dm_target_list); /* initialize global target list */
267 lockinit(&dm_target_mutex, "dmtrgt", 0, LK_CANRECURSE);
268
269 return 0;
270 }
271
272 /*
273 * Destroy all targets and remove them from queue.
274 * This routine is called from dmdestroy, before module
275 * is unloaded.
276 */
277 int
dm_target_uninit(void)278 dm_target_uninit(void)
279 {
280 dm_target_t *dm_target;
281
282 lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
283
284 while ((dm_target = TAILQ_FIRST(&dm_target_list)) != NULL) {
285 TAILQ_REMOVE(&dm_target_list, dm_target, dm_target_next);
286 dm_target_free(dm_target);
287 }
288 KKASSERT(TAILQ_EMPTY(&dm_target_list));
289
290 lockmgr(&dm_target_mutex, LK_RELEASE);
291
292 lockuninit(&dm_target_mutex);
293
294 return 0;
295 }
296