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 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright (c) 2019, Joyent, Inc. All rights reserved.
28 */
29
30 #include <signal.h>
31 #include <dirent.h>
32 #include <limits.h>
33 #include <alloca.h>
34 #include <unistd.h>
35 #include <stdio.h>
36 #include <pthread.h>
37 #include <synch.h>
38 #include <errno.h>
39 #include <strings.h>
40 #include <assert.h>
41 #include <sys/nvpair.h>
42
43 #include <topo_string.h>
44 #include <topo_alloc.h>
45 #include <topo_module.h>
46 #include <topo_error.h>
47 #include <topo_subr.h>
48
49 extern nv_alloc_ops_t topo_nv_alloc_ops;
50
51 void
topo_mod_release(topo_mod_t * mod,tnode_t * node)52 topo_mod_release(topo_mod_t *mod, tnode_t *node)
53 {
54 topo_mod_enter(mod);
55
56 if (mod->tm_info->tmi_ops->tmo_release != NULL)
57 mod->tm_info->tmi_ops->tmo_release(mod, node);
58
59 topo_mod_exit(mod);
60 }
61
62 void
topo_mod_hold(topo_mod_t * mod)63 topo_mod_hold(topo_mod_t *mod)
64 {
65 (void) pthread_mutex_lock(&mod->tm_lock);
66 mod->tm_refs++;
67 assert(mod->tm_refs != 0);
68 (void) pthread_mutex_unlock(&mod->tm_lock);
69 }
70
71 void
topo_mod_rele(topo_mod_t * mod)72 topo_mod_rele(topo_mod_t *mod)
73 {
74 assert(mod->tm_refs != 0);
75
76 (void) pthread_mutex_lock(&mod->tm_lock);
77
78 /*
79 * Lazy unload module
80 */
81 if (--mod->tm_refs == 0)
82 topo_modhash_unload(mod);
83 else
84 (void) pthread_mutex_unlock(&mod->tm_lock);
85 }
86
87 void
topo_mod_enter(topo_mod_t * mod)88 topo_mod_enter(topo_mod_t *mod)
89 {
90 (void) pthread_mutex_lock(&mod->tm_lock);
91
92 while (mod->tm_busy != 0)
93 (void) pthread_cond_wait(&mod->tm_cv, &mod->tm_lock);
94
95 ++mod->tm_busy;
96
97 (void) pthread_mutex_unlock(&mod->tm_lock);
98 }
99
100 void
topo_mod_exit(topo_mod_t * mod)101 topo_mod_exit(topo_mod_t *mod)
102 {
103 (void) pthread_mutex_lock(&mod->tm_lock);
104 --mod->tm_busy;
105
106 assert(mod->tm_busy == 0);
107
108 (void) pthread_cond_broadcast(&mod->tm_cv);
109 (void) pthread_mutex_unlock(&mod->tm_lock);
110 }
111
112 static void
topo_modhash_lock(topo_modhash_t * mhp)113 topo_modhash_lock(topo_modhash_t *mhp)
114 {
115 (void) pthread_mutex_lock(&mhp->mh_lock);
116 }
117
118 static void
topo_modhash_unlock(topo_modhash_t * mhp)119 topo_modhash_unlock(topo_modhash_t *mhp)
120 {
121 (void) pthread_mutex_unlock(&mhp->mh_lock);
122 }
123
124 static void
topo_mod_stop(topo_mod_t * mod)125 topo_mod_stop(topo_mod_t *mod)
126 {
127 if (mod->tm_flags & TOPO_MOD_INIT) {
128 (void) mod->tm_mops->mop_fini(mod);
129 if (mod->tm_flags & TOPO_MOD_REG)
130 topo_mod_unregister(mod);
131 }
132
133 mod->tm_flags = TOPO_MOD_FINI;
134
135 topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC,
136 "module %s stopped\n", mod->tm_name);
137 }
138
139 static int
topo_mod_start(topo_mod_t * mod,topo_version_t version)140 topo_mod_start(topo_mod_t *mod, topo_version_t version)
141 {
142 topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC,
143 "starting module %s\n", mod->tm_name);
144
145 if (mod->tm_mops->mop_init(mod, version) != 0) {
146 if (mod->tm_errno == 0)
147 mod->tm_errno = ETOPO_MOD_INIT;
148 topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR,
149 "module %s failed to initialize: %s\n", mod->tm_name,
150 topo_strerror(mod->tm_errno));
151 return (-1);
152 }
153
154 mod->tm_flags |= TOPO_MOD_INIT;
155
156 if (!(mod->tm_flags & TOPO_MOD_REG)) {
157 topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR,
158 "module %s failed to register\n", mod->tm_name);
159 mod->tm_errno = ETOPO_MOD_NOREG;
160 topo_mod_stop(mod);
161 return (-1);
162 }
163
164 return (0);
165 }
166
167 topo_mod_t *
topo_mod_lookup(topo_hdl_t * thp,const char * name,int bump)168 topo_mod_lookup(topo_hdl_t *thp, const char *name, int bump)
169 {
170 topo_mod_t *mod;
171 topo_modhash_t *mhp = thp->th_modhash;
172
173 topo_modhash_lock(mhp);
174 mod = topo_modhash_lookup(mhp, name);
175 if (mod != NULL && bump != 0)
176 topo_mod_hold(mod);
177 topo_modhash_unlock(mhp);
178
179 return (mod);
180 }
181
182 static void
topo_mod_destroy(topo_mod_t * mod)183 topo_mod_destroy(topo_mod_t *mod)
184 {
185 topo_hdl_t *thp;
186
187 if (mod == NULL)
188 return;
189
190 thp = mod->tm_hdl;
191
192 assert(mod->tm_refs == 0);
193 assert(!MUTEX_HELD(&mod->tm_lock));
194
195 if (mod->tm_name != NULL)
196 topo_hdl_strfree(thp, mod->tm_name);
197 if (mod->tm_path != NULL)
198 topo_hdl_strfree(thp, mod->tm_path);
199 if (mod->tm_rootdir != NULL)
200 topo_hdl_strfree(thp, mod->tm_rootdir);
201
202 topo_hdl_free(thp, mod, sizeof (topo_mod_t));
203 }
204
205 static topo_mod_t *
set_create_error(topo_hdl_t * thp,topo_mod_t * mod,const char * path,int err)206 set_create_error(topo_hdl_t *thp, topo_mod_t *mod, const char *path, int err)
207 {
208 if (path != NULL)
209 topo_dprintf(thp, TOPO_DBG_ERR, "unable to load module %s: "
210 "%s\n", path, topo_strerror(err));
211 else
212 topo_dprintf(thp, TOPO_DBG_ERR, "unable to load module: "
213 "%s\n", topo_strerror(err));
214
215 if (mod != NULL)
216 topo_mod_destroy(mod);
217
218 (void) topo_hdl_seterrno(thp, err);
219
220 return (NULL);
221 }
222
223 static topo_mod_t *
topo_mod_create(topo_hdl_t * thp,const char * name,const char * path,const topo_imodops_t * ops,topo_version_t version)224 topo_mod_create(topo_hdl_t *thp, const char *name, const char *path,
225 const topo_imodops_t *ops, topo_version_t version)
226 {
227 topo_mod_t *mod;
228
229 if (topo_modhash_lookup(thp->th_modhash, name) != NULL)
230 return (set_create_error(thp, NULL, path, ETOPO_MOD_LOADED));
231
232 if ((mod = topo_hdl_zalloc(thp, sizeof (topo_mod_t))) == NULL)
233 return (set_create_error(thp, mod, path, ETOPO_NOMEM));
234
235 mod->tm_hdl = thp;
236
237 (void) pthread_mutex_init(&mod->tm_lock, NULL);
238
239 mod->tm_name = topo_hdl_strdup(thp, name);
240 if (path != NULL)
241 mod->tm_path = topo_hdl_strdup(thp, path);
242 mod->tm_rootdir = topo_hdl_strdup(thp, thp->th_rootdir);
243 if (mod->tm_name == NULL || mod->tm_rootdir == NULL)
244 return (set_create_error(thp, mod, path, ETOPO_NOMEM));
245
246 mod->tm_mops = (topo_imodops_t *)ops;
247 mod->tm_alloc = thp->th_alloc;
248
249 /*
250 * Module will be held upon a successful return from topo_mod_start()
251 */
252 if ((topo_mod_start(mod, version)) < 0)
253 return (set_create_error(thp, mod, path, mod->tm_errno));
254
255 topo_dprintf(thp, TOPO_DBG_MODSVC, "loaded module %s\n", mod->tm_name);
256
257 return (mod);
258 }
259
260 topo_modhash_t *
topo_modhash_create(topo_hdl_t * thp)261 topo_modhash_create(topo_hdl_t *thp)
262 {
263 topo_modhash_t *mhp;
264
265 if ((mhp = topo_hdl_zalloc(thp, sizeof (topo_modhash_t))) == NULL)
266 return (NULL);
267
268 mhp->mh_hashlen = TOPO_HASH_BUCKETS;
269 if ((mhp->mh_hash = topo_hdl_zalloc(thp,
270 sizeof (void *) * mhp->mh_hashlen)) == NULL) {
271 topo_hdl_free(thp, mhp, sizeof (topo_modhash_t));
272 return (NULL);
273 }
274 mhp->mh_nelems = 0;
275 (void) pthread_mutex_init(&mhp->mh_lock, NULL);
276
277 thp->th_modhash = mhp;
278
279 return (mhp);
280 }
281
282 void
topo_modhash_destroy(topo_hdl_t * thp)283 topo_modhash_destroy(topo_hdl_t *thp)
284 {
285 topo_modhash_t *mhp = thp->th_modhash;
286
287 if (mhp == NULL)
288 return;
289
290 assert(mhp->mh_nelems == 0);
291
292 topo_hdl_free(thp, mhp->mh_hash, sizeof (void *) * mhp->mh_hashlen);
293 topo_hdl_free(thp, mhp, sizeof (topo_modhash_t));
294 thp->th_modhash = NULL;
295 }
296
297 topo_mod_t *
topo_modhash_lookup(topo_modhash_t * mhp,const char * name)298 topo_modhash_lookup(topo_modhash_t *mhp, const char *name)
299 {
300 topo_mod_t *mod = NULL;
301 uint_t h;
302
303 h = topo_strhash(name) % mhp->mh_hashlen;
304
305 for (mod = mhp->mh_hash[h]; mod != NULL; mod = mod->tm_next) {
306 if (strcmp(name, mod->tm_name) == 0)
307 break;
308 }
309
310 return (mod);
311 }
312
313 topo_mod_t *
topo_modhash_load(topo_hdl_t * thp,const char * name,const char * path,const topo_imodops_t * ops,topo_version_t version)314 topo_modhash_load(topo_hdl_t *thp, const char *name, const char *path,
315 const topo_imodops_t *ops, topo_version_t version)
316 {
317 topo_modhash_t *mhp = thp->th_modhash;
318 topo_mod_t *mod;
319 uint_t h;
320
321 topo_modhash_lock(mhp);
322
323 if ((mod = topo_mod_create(thp, name, path, ops, version)) == NULL) {
324 topo_modhash_unlock(mhp);
325 return (NULL); /* th_errno set */
326 }
327
328 topo_mod_hold(mod);
329
330 h = topo_strhash(name) % mhp->mh_hashlen;
331 mod->tm_next = mhp->mh_hash[h];
332 mhp->mh_hash[h] = mod;
333 mhp->mh_nelems++;
334 topo_modhash_unlock(mhp);
335
336 return (mod);
337 }
338
339 void
topo_modhash_unload(topo_mod_t * mod)340 topo_modhash_unload(topo_mod_t *mod)
341 {
342 uint_t h;
343 topo_mod_t **pp, *mp;
344 topo_hdl_t *thp = mod->tm_hdl;
345 topo_modhash_t *mhp;
346
347 assert(MUTEX_HELD(&mod->tm_lock));
348 assert(mod->tm_busy == 0);
349
350 mhp = thp->th_modhash;
351 topo_modhash_lock(mhp);
352
353 assert(mhp != NULL);
354
355 h = topo_strhash(mod->tm_name) % mhp->mh_hashlen;
356 pp = &mhp->mh_hash[h];
357
358 for (mp = *pp; mp != NULL; mp = mp->tm_next) {
359 if (mp == mod)
360 break;
361 else
362 pp = &mp->tm_next;
363 }
364
365 if (mp != NULL) {
366 *pp = mod->tm_next;
367
368 assert(mhp->mh_nelems != 0);
369
370 mhp->mh_nelems--;
371
372 }
373 topo_modhash_unlock(mhp);
374
375 (void) pthread_mutex_unlock(&mod->tm_lock);
376
377 topo_mod_stop(mod);
378 topo_mod_destroy(mod);
379
380 }
381
382 void
topo_modhash_unload_all(topo_hdl_t * thp)383 topo_modhash_unload_all(topo_hdl_t *thp)
384 {
385 int i;
386 topo_modhash_t *mhp = thp->th_modhash;
387 topo_mod_t *mp, **pp;
388
389 if (mhp == NULL)
390 return;
391
392 topo_modhash_lock(mhp);
393 for (i = 0; i < TOPO_HASH_BUCKETS; ++i) {
394 pp = &mhp->mh_hash[i];
395 mp = *pp;
396 while (mp != NULL) {
397 topo_mod_stop(mp);
398
399 /*
400 * At this point we are forcing all modules to
401 * stop, ignore any remaining module reference counts.
402 */
403 mp->tm_refs = 0;
404
405 *pp = mp->tm_next;
406 topo_mod_destroy(mp);
407 mp = *pp;
408
409 --mhp->mh_nelems;
410 }
411 }
412 topo_modhash_unlock(mhp);
413 }
414