Lines Matching refs:mp
55 * module. These are used to initialize the per-module mp->mod_stats below.
100 fmd_module_t *mp = arg;
104 (void) pthread_mutex_lock(&mp->mod_lock);
106 if (mp->mod_ops->mop_init(mp) != 0 || mp->mod_error != 0) {
107 if (mp->mod_error == 0)
108 mp->mod_error = errno ? errno : EFMD_MOD_INIT;
113 fmd_eventq_insert_at_head(mp->mod_queue, fmd.d_mod_event);
115 ASSERT(MUTEX_HELD(&mp->mod_lock));
116 mp->mod_flags |= FMD_MOD_INIT;
118 (void) pthread_cond_broadcast(&mp->mod_cv);
119 (void) pthread_mutex_unlock(&mp->mod_lock);
125 for (xp = fmd_list_next(&mp->mod_transports);
134 while ((ep = fmd_eventq_delete(mp->mod_queue)) != NULL) {
139 if (mp->mod_error != 0) {
140 fmd_eventq_done(mp->mod_queue);
145 mp->mod_ops->mop_dispatch(mp, ep);
146 fmd_eventq_done(mp->mod_queue);
153 fmd_module_lock(mp);
158 fmd_ckpt_save(mp);
159 fmd_module_unlock(mp);
163 if (mp->mod_ops->mop_fini(mp) != 0 && mp->mod_error == 0)
164 mp->mod_error = errno ? errno : EFMD_MOD_FINI;
166 (void) pthread_mutex_lock(&mp->mod_lock);
167 mp->mod_flags |= FMD_MOD_FINI;
170 (void) pthread_cond_broadcast(&mp->mod_cv);
171 (void) pthread_mutex_unlock(&mp->mod_lock);
177 fmd_module_t *mp = fmd_zalloc(sizeof (fmd_module_t), FMD_SLEEP);
188 (void) pthread_mutex_init(&mp->mod_lock, NULL);
189 (void) pthread_cond_init(&mp->mod_cv, NULL);
190 (void) pthread_mutex_init(&mp->mod_stats_lock, NULL);
192 mp->mod_name = fmd_strdup(buf, FMD_SLEEP);
193 mp->mod_path = fmd_strdup(path, FMD_SLEEP);
194 mp->mod_ops = ops;
195 mp->mod_ustat = fmd_ustat_create();
199 "%s/%s/%s", fmd.d_rootdir, dir, mp->mod_name);
201 mp->mod_ckpt = fmd_strdup(buf, FMD_SLEEP);
204 mp->mod_timerids = fmd_idspace_create(mp->mod_name, 1, limit + 1);
205 mp->mod_threads = fmd_idspace_create(mp->mod_name, 0, INT_MAX);
207 fmd_buf_hash_create(&mp->mod_bufs);
208 fmd_serd_hash_create(&mp->mod_serds);
210 mp->mod_topo_current = fmd_topo_hold();
213 fmd_list_append(&fmd.d_mod_list, mp);
220 if ((mp->mod_stats = (fmd_modstat_t *)fmd_ustat_insert(mp->mod_ustat,
224 fmd_module_destroy(mp);
228 if (nv_alloc_init(&mp->mod_nva_sleep,
229 &fmd_module_nva_ops_sleep, mp) != 0 ||
230 nv_alloc_init(&mp->mod_nva_nosleep,
231 &fmd_module_nva_ops_nosleep, mp) != 0) {
234 fmd_module_destroy(mp);
240 mp->mod_queue = fmd_eventq_create(mp,
241 &mp->mod_stats->ms_evqstat, &mp->mod_stats_lock, limit);
244 &mp->mod_stats->ms_memlimit.fmds_value.ui64);
247 &mp->mod_stats->ms_buflimit.fmds_value.ui64);
250 &mp->mod_stats->ms_thrlimit.fmds_value.ui32);
253 &mp->mod_stats->ms_doorthrlimit.fmds_value.ui32);
256 &mp->mod_stats->ms_xprtlimit.fmds_value.ui32);
259 &mp->mod_stats->ms_xprtqlimit.fmds_value.ui32);
262 &mp->mod_stats->ms_ckpt_save.fmds_value.bool);
265 &mp->mod_stats->ms_ckpt_restore.fmds_value.bool);
268 &mp->mod_stats->ms_ckpt_zeroed.fmds_value.bool);
270 if (mp->mod_stats->ms_ckpt_zeroed.fmds_value.bool)
271 fmd_ckpt_delete(mp); /* blow away any pre-existing checkpoint */
279 fmd_module_hold(mp);
280 (void) pthread_mutex_lock(&mp->mod_lock);
281 mp->mod_stats->ms_loadtime.fmds_value.ui64 = gethrtime();
282 mp->mod_thread = fmd_thread_create(mp, fmd_module_start, mp);
284 if (mp->mod_thread == NULL) {
286 (void) pthread_mutex_unlock(&mp->mod_lock);
287 fmd_module_rele(mp);
297 while (!(mp->mod_flags & FMD_MOD_INIT) && mp->mod_error == 0)
298 (void) pthread_cond_wait(&mp->mod_cv, &mp->mod_lock);
304 if (!(mp->mod_flags & FMD_MOD_INIT)) {
305 err = mp->mod_error;
306 (void) pthread_mutex_unlock(&mp->mod_lock);
309 fmd_ckpt_rename(mp); /* move aside bad checkpoint */
323 fmd_module_unload(mp);
324 fmd_module_rele(mp);
330 (void) pthread_cond_broadcast(&mp->mod_cv);
331 (void) pthread_mutex_unlock(&mp->mod_lock);
333 fmd_dprintf(FMD_DBG_MOD, "loaded module %s\n", mp->mod_name);
334 return (mp);
338 fmd_module_untimeout(fmd_idspace_t *ids, id_t id, fmd_module_t *mp)
347 if (arg != NULL && mp != fmd.d_rmod)
352 fmd_module_unload(fmd_module_t *mp)
356 (void) pthread_mutex_lock(&mp->mod_lock);
358 if (mp->mod_flags & FMD_MOD_QUIT) {
359 (void) pthread_mutex_unlock(&mp->mod_lock);
363 ASSERT(mp->mod_thread != NULL);
364 mp->mod_flags |= FMD_MOD_QUIT;
366 if (mp->mod_queue != NULL)
367 fmd_eventq_abort(mp->mod_queue);
374 while ((mp->mod_flags & (FMD_MOD_INIT | FMD_MOD_FINI)) == FMD_MOD_INIT)
375 (void) pthread_cond_wait(&mp->mod_cv, &mp->mod_lock);
377 (void) pthread_cond_broadcast(&mp->mod_cv);
378 (void) pthread_mutex_unlock(&mp->mod_lock);
380 fmd_thread_destroy(mp->mod_thread, FMD_THREAD_JOIN);
381 mp->mod_thread = NULL;
387 fmd_module_lock(mp);
389 if (mp->mod_timerids != NULL) {
390 fmd_idspace_apply(mp->mod_timerids,
391 (void (*)())fmd_module_untimeout, mp);
393 fmd_idspace_destroy(mp->mod_timerids);
394 mp->mod_timerids = NULL;
397 if (mp->mod_threads != NULL) {
398 fmd_idspace_destroy(mp->mod_threads);
399 mp->mod_threads = NULL;
402 (void) fmd_buf_hash_destroy(&mp->mod_bufs);
403 fmd_serd_hash_destroy(&mp->mod_serds);
405 while ((mtp = fmd_list_next(&mp->mod_topolist)) != NULL) {
406 fmd_list_delete(&mp->mod_topolist, mtp);
411 fmd_module_unlock(mp);
412 fmd_dprintf(FMD_DBG_MOD, "unloaded module %s\n", mp->mod_name);
416 fmd_module_destroy(fmd_module_t *mp)
418 fmd_conf_formal_t *cfp = mp->mod_argv;
421 ASSERT(MUTEX_HELD(&mp->mod_lock));
423 if (mp->mod_thread != NULL) {
424 (void) pthread_mutex_unlock(&mp->mod_lock);
425 fmd_module_unload(mp);
426 (void) pthread_mutex_lock(&mp->mod_lock);
429 ASSERT(mp->mod_thread == NULL);
430 ASSERT(mp->mod_refs == 0);
438 fmd_list_delete(&fmd.d_mod_list, mp);
441 if (mp->mod_topo_current != NULL)
442 fmd_topo_rele(mp->mod_topo_current);
444 if (mp->mod_nva_sleep.nva_ops != NULL)
445 nv_alloc_fini(&mp->mod_nva_sleep);
446 if (mp->mod_nva_nosleep.nva_ops != NULL)
447 nv_alloc_fini(&mp->mod_nva_nosleep);
453 if (mp->mod_queue != NULL) {
454 fmd_eventq_destroy(mp->mod_queue);
455 mp->mod_queue = NULL;
458 if (mp->mod_ustat != NULL) {
459 (void) pthread_mutex_lock(&mp->mod_stats_lock);
460 fmd_ustat_destroy(mp->mod_ustat);
461 mp->mod_ustat = NULL;
462 mp->mod_stats = NULL;
463 (void) pthread_mutex_unlock(&mp->mod_stats_lock);
466 for (i = 0; i < mp->mod_dictc; i++)
467 fm_dc_closedict(mp->mod_dictv[i]);
469 fmd_free(mp->mod_dictv, sizeof (struct fm_dc_handle *) * mp->mod_dictc);
471 if (mp->mod_conf != NULL)
472 fmd_conf_close(mp->mod_conf);
474 for (i = 0; i < mp->mod_argc; i++, cfp++) {
479 fmd_free(mp->mod_argv, sizeof (fmd_conf_formal_t) * mp->mod_argc);
481 fmd_strfree(mp->mod_name);
482 fmd_strfree(mp->mod_path);
483 fmd_strfree(mp->mod_ckpt);
484 nvlist_free(mp->mod_fmri);
485 fmd_strfree(mp->mod_vers);
487 fmd_free(mp, sizeof (fmd_module_t));
497 fmd_module_error(fmd_module_t *mp, int err)
503 ASSERT(MUTEX_HELD(&mp->mod_lock));
508 if (mp->mod_error == 0)
509 mp->mod_error = err;
511 if (mp == fmd.d_self)
521 nvl = fmd_protocol_moderror(mp, EFMD_MOD_FAIL, fmd_strerror(err));
528 fmd_module_dispatch(fmd_module_t *mp, fmd_event_t *e)
530 const fmd_hdl_ops_t *ops = mp->mod_info->fmdi_ops;
532 fmd_hdl_t *hdl = (fmd_hdl_t *)mp;
541 (void) pthread_mutex_lock(&mp->mod_lock);
543 ASSERT(!(mp->mod_flags & FMD_MOD_BUSY));
544 mp->mod_flags |= FMD_MOD_BUSY;
546 if ((err = setjmp(mp->mod_jmpbuf)) != 0) {
547 (void) pthread_mutex_lock(&mp->mod_lock);
548 fmd_module_error(mp, err);
551 (void) pthread_cond_broadcast(&mp->mod_cv);
552 (void) pthread_mutex_unlock(&mp->mod_lock);
567 ASSERT(t->mt_mod == mp);
575 fmd_modstat_publish(mp);
594 old_topo = mp->mod_topo_current;
595 fmd_module_lock(mp);
596 mp->mod_topo_current = (fmd_topo_t *)ep->ev_data;
597 fmd_topo_addref(mp->mod_topo_current);
598 fmd_module_unlock(mp);
600 ops->fmdo_topo(hdl, mp->mod_topo_current->ft_hdl);
605 fmd_module_exit(mp);
609 fmd_module_transport(fmd_module_t *mp, fmd_xprt_t *xp, fmd_event_t *e)
612 fmd_hdl_t *hdl = (fmd_hdl_t *)mp;
615 return (mp->mod_info->fmdi_ops->fmdo_send(hdl, xp, e, ep->ev_nvl));
633 fmd_module_gc(fmd_module_t *mp)
638 if (mp->mod_error != 0)
641 fmd_module_lock(mp);
643 if ((info = mp->mod_info) != NULL) {
644 fmd_serd_hash_apply(&mp->mod_serds,
648 fmd_module_unlock(mp);
652 fmd_eventq_insert_at_head(mp->mod_queue, e);
657 fmd_module_trygc(fmd_module_t *mp)
659 if (fmd_module_trylock(mp)) {
660 fmd_serd_hash_apply(&mp->mod_serds,
662 fmd_module_unlock(mp);
667 fmd_module_contains(fmd_module_t *mp, fmd_event_t *ep)
672 fmd_module_lock(mp);
674 for (cp = fmd_list_next(&mp->mod_cases);
681 rv = fmd_serd_hash_contains(&mp->mod_serds, ep);
683 fmd_module_unlock(mp);
688 fmd_module_setdirty(fmd_module_t *mp)
690 (void) pthread_mutex_lock(&mp->mod_lock);
691 mp->mod_flags |= FMD_MOD_MDIRTY;
692 (void) pthread_mutex_unlock(&mp->mod_lock);
696 fmd_module_setcdirty(fmd_module_t *mp)
698 (void) pthread_mutex_lock(&mp->mod_lock);
699 mp->mod_flags |= FMD_MOD_CDIRTY;
700 (void) pthread_mutex_unlock(&mp->mod_lock);
704 fmd_module_clrdirty(fmd_module_t *mp)
708 fmd_module_lock(mp);
710 if (mp->mod_flags & FMD_MOD_CDIRTY) {
711 for (cp = fmd_list_next(&mp->mod_cases);
716 if (mp->mod_flags & FMD_MOD_MDIRTY) {
717 fmd_serd_hash_apply(&mp->mod_serds,
719 fmd_buf_hash_commit(&mp->mod_bufs);
722 (void) pthread_mutex_lock(&mp->mod_lock);
723 mp->mod_flags &= ~(FMD_MOD_MDIRTY | FMD_MOD_CDIRTY);
724 (void) pthread_mutex_unlock(&mp->mod_lock);
726 fmd_module_unlock(mp);
730 fmd_module_commit(fmd_module_t *mp)
734 ASSERT(fmd_module_locked(mp));
736 if (mp->mod_flags & FMD_MOD_CDIRTY) {
737 for (cp = fmd_list_next(&mp->mod_cases);
742 if (mp->mod_flags & FMD_MOD_MDIRTY) {
743 fmd_serd_hash_apply(&mp->mod_serds,
745 fmd_buf_hash_commit(&mp->mod_bufs);
748 (void) pthread_mutex_lock(&mp->mod_lock);
749 mp->mod_flags &= ~(FMD_MOD_MDIRTY | FMD_MOD_CDIRTY);
750 (void) pthread_mutex_unlock(&mp->mod_lock);
752 mp->mod_gen++;
756 fmd_module_lock(fmd_module_t *mp)
760 (void) pthread_mutex_lock(&mp->mod_lock);
762 while (mp->mod_flags & FMD_MOD_LOCK) {
763 if (mp->mod_owner != self)
764 (void) pthread_cond_wait(&mp->mod_cv, &mp->mod_lock);
766 fmd_panic("recursive module lock of %p\n", (void *)mp);
769 mp->mod_owner = self;
770 mp->mod_flags |= FMD_MOD_LOCK;
772 (void) pthread_cond_broadcast(&mp->mod_cv);
773 (void) pthread_mutex_unlock(&mp->mod_lock);
777 fmd_module_unlock(fmd_module_t *mp)
779 (void) pthread_mutex_lock(&mp->mod_lock);
781 ASSERT(mp->mod_owner == pthread_self());
782 ASSERT(mp->mod_flags & FMD_MOD_LOCK);
784 mp->mod_owner = 0;
785 mp->mod_flags &= ~FMD_MOD_LOCK;
787 (void) pthread_cond_broadcast(&mp->mod_cv);
788 (void) pthread_mutex_unlock(&mp->mod_lock);
792 fmd_module_trylock(fmd_module_t *mp)
794 (void) pthread_mutex_lock(&mp->mod_lock);
796 if (mp->mod_flags & FMD_MOD_LOCK) {
797 (void) pthread_mutex_unlock(&mp->mod_lock);
801 mp->mod_owner = pthread_self();
802 mp->mod_flags |= FMD_MOD_LOCK;
804 (void) pthread_cond_broadcast(&mp->mod_cv);
805 (void) pthread_mutex_unlock(&mp->mod_lock);
811 fmd_module_locked(fmd_module_t *mp)
813 return ((mp->mod_flags & FMD_MOD_LOCK) &&
814 mp->mod_owner == pthread_self());
818 fmd_module_enter(fmd_module_t *mp, void (*func)(fmd_hdl_t *))
822 (void) pthread_mutex_lock(&mp->mod_lock);
824 ASSERT(!(mp->mod_flags & FMD_MOD_BUSY));
825 mp->mod_flags |= FMD_MOD_BUSY;
827 if ((err = setjmp(mp->mod_jmpbuf)) != 0) {
828 (void) pthread_mutex_lock(&mp->mod_lock);
829 fmd_module_error(mp, err);
832 (void) pthread_cond_broadcast(&mp->mod_cv);
833 (void) pthread_mutex_unlock(&mp->mod_lock);
842 (*func)((fmd_hdl_t *)mp);
848 fmd_module_exit(fmd_module_t *mp)
850 (void) pthread_mutex_lock(&mp->mod_lock);
852 ASSERT(mp->mod_flags & FMD_MOD_BUSY);
853 mp->mod_flags &= ~FMD_MOD_BUSY;
855 (void) pthread_cond_broadcast(&mp->mod_cv);
856 (void) pthread_mutex_unlock(&mp->mod_lock);
868 fmd_module_abort(fmd_module_t *mp, int err)
877 fmd_errclass(err), mp->mod_name, (void *)mp);
881 fmd_errclass(err), mp->mod_name, (void *)mp);
900 if (tid != mp->mod_thread->thr_tid) {
901 (void) pthread_mutex_lock(&mp->mod_lock);
903 if (mp->mod_error == 0)
904 mp->mod_error = err;
906 mp->mod_flags |= FMD_MOD_FAIL;
907 (void) pthread_mutex_unlock(&mp->mod_lock);
913 ASSERT(mp->mod_flags & FMD_MOD_BUSY);
914 longjmp(mp->mod_jmpbuf, err);
918 fmd_module_hold(fmd_module_t *mp)
920 (void) pthread_mutex_lock(&mp->mod_lock);
923 (void *)mp, mp->mod_name, mp->mod_refs));
925 mp->mod_refs++;
926 ASSERT(mp->mod_refs != 0);
928 (void) pthread_mutex_unlock(&mp->mod_lock);
932 fmd_module_rele(fmd_module_t *mp)
934 (void) pthread_mutex_lock(&mp->mod_lock);
937 (void *)mp, mp->mod_name, mp->mod_refs));
939 ASSERT(mp->mod_refs != 0);
941 if (--mp->mod_refs == 0)
942 fmd_module_destroy(mp);
944 (void) pthread_mutex_unlock(&mp->mod_lock);
953 fmd_module_dc_opendict(fmd_module_t *mp, const char *dict)
959 ASSERT(fmd_module_locked(mp));
986 mp->mod_name, dict, dictdir, dictnam);
991 dcv = fmd_alloc(sizeof (dcp) * (mp->mod_dictc + 1), FMD_SLEEP);
992 bcopy(mp->mod_dictv, dcv, sizeof (dcp) * mp->mod_dictc);
993 fmd_free(mp->mod_dictv, sizeof (dcp) * mp->mod_dictc);
994 mp->mod_dictv = dcv;
995 mp->mod_dictv[mp->mod_dictc++] = dcp;
998 mp->mod_codelen = MAX(mp->mod_codelen, len);
1008 fmd_module_dc_key2code(fmd_module_t *mp,
1013 for (i = 0; i < mp->mod_dictc; i++) {
1014 if ((err = fm_dc_key2code(mp->mod_dictv[i], (const char **)keys,
1038 fmd_module_t *mp, *nmp;
1042 for (mp = mhp->mh_hash[i]; mp != NULL; mp = nmp) {
1043 nmp = mp->mod_next;
1044 mp->mod_next = NULL;
1045 fmd_module_rele(mp);
1098 fmd_module_t *mp, *np;
1104 for (mp = mhp->mh_hash[i]; mp != NULL; mp = np) {
1105 np = mp->mod_next;
1106 func(mp);
1116 fmd_module_t *mp, *np;
1123 for (mp = mhp->mh_hash[i]; mp != NULL; mp = np) {
1124 np = mp->mod_next;
1125 func(mp);
1135 fmd_module_t *mp;
1142 for (mp = mhp->mh_hash[i]; mp != NULL; mp = mp->mod_next) {
1148 (void) pthread_mutex_lock(&mp->mod_lock);
1150 if ((mp->mod_flags & (FMD_MOD_INIT | FMD_MOD_FINI |
1151 FMD_MOD_QUIT)) == FMD_MOD_INIT && !mp->mod_error) {
1160 fmd_eventq_drop_topo(mp->mod_queue);
1162 fmd_eventq_insert_at_time(mp->mod_queue, ep);
1165 (void) pthread_mutex_unlock(&mp->mod_lock);
1176 fmd_module_t *mp;
1182 for (mp = mhp->mh_hash[h]; mp != NULL; mp = mp->mod_next) {
1183 if (strcmp(name, mp->mod_name) == 0)
1187 if (mp != NULL)
1188 fmd_module_hold(mp);
1193 return (mp);
1200 fmd_module_t *mp;
1215 for (mp = mhp->mh_hash[h]; mp != NULL; mp = mp->mod_next) {
1216 if (strcmp(name, mp->mod_name) == 0)
1220 if (mp != NULL) {
1230 while ((mp = fmd_module_create(path, ops)) == NULL) {
1237 mp->mod_hash = mhp;
1238 mp->mod_next = mhp->mh_hash[h];
1240 mhp->mh_hash[h] = mp;
1244 return (mp);
1250 fmd_module_t *mp, **pp;
1257 for (mp = *pp; mp != NULL; mp = mp->mod_next) {
1258 if (strcmp(name, mp->mod_name) == 0)
1261 pp = &mp->mod_next;
1264 if (mp == NULL) {
1269 *pp = mp->mod_next;
1270 mp->mod_next = NULL;
1277 fmd_module_unload(mp);
1278 fmd_module_rele(mp);
1284 fmd_modstat_publish(fmd_module_t *mp)
1286 (void) pthread_mutex_lock(&mp->mod_lock);
1288 ASSERT(mp->mod_flags & FMD_MOD_STSUB);
1289 mp->mod_flags |= FMD_MOD_STPUB;
1290 (void) pthread_cond_broadcast(&mp->mod_cv);
1292 while (mp->mod_flags & FMD_MOD_STPUB)
1293 (void) pthread_cond_wait(&mp->mod_cv, &mp->mod_lock);
1295 (void) pthread_mutex_unlock(&mp->mod_lock);
1299 fmd_modstat_snapshot(fmd_module_t *mp, fmd_ustat_snap_t *uss)
1308 (void) pthread_mutex_lock(&mp->mod_lock);
1310 while (mp->mod_error == 0 && (mp->mod_flags & FMD_MOD_STSUB))
1311 (void) pthread_cond_wait(&mp->mod_cv, &mp->mod_lock);
1313 if (mp->mod_error != 0) {
1314 (void) pthread_mutex_unlock(&mp->mod_lock);
1318 mp->mod_flags |= FMD_MOD_STSUB;
1319 (void) pthread_cond_broadcast(&mp->mod_cv);
1320 (void) pthread_mutex_unlock(&mp->mod_lock);
1327 fmd_eventq_insert_at_head(mp->mod_queue, e);
1333 (void) pthread_mutex_lock(&mp->mod_lock);
1335 while (mp->mod_error == 0 && !(mp->mod_flags & FMD_MOD_STPUB)) {
1338 (void) pthread_cond_wait(&mp->mod_cv, &mp->mod_lock);
1339 (void) pthread_mutex_unlock(&mp->mod_lock);
1343 (void) pthread_mutex_lock(&mp->mod_lock);
1346 if (mp->mod_error != 0) {
1347 (void) pthread_mutex_unlock(&mp->mod_lock);
1351 (void) pthread_cond_broadcast(&mp->mod_cv);
1352 (void) pthread_mutex_unlock(&mp->mod_lock);
1358 (void) pthread_mutex_lock(&mp->mod_stats_lock);
1360 if (mp->mod_stats != NULL) {
1361 mp->mod_stats->ms_snaptime.fmds_value.ui64 = gethrtime();
1362 err = fmd_ustat_snapshot(mp->mod_ustat, uss);
1366 (void) pthread_mutex_unlock(&mp->mod_stats_lock);
1372 (void) pthread_mutex_lock(&mp->mod_lock);
1374 ASSERT(mp->mod_flags & FMD_MOD_STSUB);
1375 ASSERT(mp->mod_flags & FMD_MOD_STPUB);
1376 mp->mod_flags &= ~(FMD_MOD_STSUB | FMD_MOD_STPUB);
1378 (void) pthread_cond_broadcast(&mp->mod_cv);
1379 (void) pthread_mutex_unlock(&mp->mod_lock);
1385 fmd_module_topo_hold(fmd_module_t *mp)
1389 ASSERT(fmd_module_locked(mp));
1392 mtp->mt_topo = mp->mod_topo_current;
1394 fmd_list_prepend(&mp->mod_topolist, mtp);
1400 fmd_module_topo_rele(fmd_module_t *mp, struct topo_hdl *hdl)
1404 ASSERT(fmd_module_locked(mp));
1406 for (mtp = fmd_list_next(&mp->mod_topolist); mtp != NULL;
1415 fmd_list_delete(&mp->mod_topolist, mtp);