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 (c) 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * Receive (on GPEC channels) raw events published by a few select producers 28 * using the private libfmevent publication interfaces, and massage those 29 * raw events into full protocol events. Each raw event selects a "ruleset" 30 * by which to perform the transformation into a protocol event. 31 * 32 * Only publication from userland running privileged is supported; two 33 * channels are used - one for high-value and one for low-value events. 34 * There is some planning in the implementation below for kernel hi and low 35 * value channels, and for non-privileged userland low and hi value channels. 36 */ 37 38 #include <fm/fmd_api.h> 39 #include <fm/libfmevent.h> 40 #include <uuid/uuid.h> 41 #include <libsysevent.h> 42 #include <pthread.h> 43 #include <libnvpair.h> 44 #include <strings.h> 45 #include <zone.h> 46 47 #include "fmevt.h" 48 49 static struct fmevt_inbound_stats { 50 fmd_stat_t raw_callbacks; 51 fmd_stat_t raw_noattrlist; 52 fmd_stat_t raw_nodetector; 53 fmd_stat_t pp_bad_ruleset; 54 fmd_stat_t pp_explicitdrop; 55 fmd_stat_t pp_fallthrurule; 56 fmd_stat_t pp_fanoutmax; 57 fmd_stat_t pp_intldrop; 58 fmd_stat_t pp_badclass; 59 fmd_stat_t pp_nvlallocfail; 60 fmd_stat_t pp_nvlbuildfail; 61 fmd_stat_t pp_badreturn; 62 fmd_stat_t xprt_posted; 63 } inbound_stats = { 64 { "raw_callbacks", FMD_TYPE_UINT64, 65 "total raw event callbacks from producers" }, 66 { "raw_noattrlist", FMD_TYPE_UINT64, 67 "missing attribute list" }, 68 { "raw_nodetector", FMD_TYPE_UINT64, 69 "unable to add detector" }, 70 { "pp_bad_ruleset", FMD_TYPE_UINT64, 71 "post-process bad ruleset" }, 72 { "pp_explicitdrop", FMD_TYPE_UINT64, 73 "ruleset drops event with NULL func" }, 74 { "pp_fanoutmax", FMD_TYPE_UINT64, 75 "post-processing produced too many events" }, 76 { "pp_intldrop", FMD_TYPE_UINT64, 77 "post-processing requested event drop" }, 78 { "pp_badclass", FMD_TYPE_UINT64, 79 "post-processing produced invalid event class" }, 80 { "pp_nvlallocfail", FMD_TYPE_UINT64, 81 "fmd_nvl_alloc failed" }, 82 { "pp_nvlbuildfail", FMD_TYPE_UINT64, 83 "nvlist_add_foo failed in building event" }, 84 { "pp_badreturn", FMD_TYPE_UINT64, 85 "inconsistent number of events returned" }, 86 { "xprt_posted", FMD_TYPE_UINT64, 87 "protocol events posted with fmd_xprt_post" }, 88 }; 89 90 static int isglobalzone; 91 static char zonename[ZONENAME_MAX]; 92 93 #define BUMPSTAT(stat) inbound_stats.stat.fmds_value.ui64++ 94 95 #define CBF_USER 0x1U 96 #define CBF_PRIV 0x2U 97 #define CBF_LV 0x4U 98 #define CBF_HV 0x8U 99 #define CBF_ALL (CBF_USER | CBF_PRIV | CBF_LV | CBF_HV) 100 101 static struct fmevt_chaninfo { 102 const char *ci_propname; /* property to get channel name */ 103 evchan_t *ci_binding; /* GPEC binding for this channel */ 104 char ci_sid[MAX_SUBID_LEN]; /* subscriber id */ 105 uint32_t ci_cbarg; /* callback cookie */ 106 uint32_t ci_sflags; /* subscription flags to use */ 107 } chaninfo[] = { 108 { "user_priv_highval_channel", NULL, { 0 }, 109 CBF_USER | CBF_PRIV | CBF_HV, EVCH_SUB_KEEP }, 110 { "user_priv_lowval_channel", NULL, { 0 }, 111 CBF_USER | CBF_PRIV | CBF_LV, EVCH_SUB_KEEP }, 112 }; 113 114 static pthread_cond_t fmevt_cv = PTHREAD_COND_INITIALIZER; 115 static pthread_mutex_t fmevt_lock = PTHREAD_MUTEX_INITIALIZER; 116 static int fmevt_exiting; 117 118 static fmd_xprt_t *fmevt_xprt; 119 static uint32_t fmevt_xprt_refcnt; 120 static sysevent_subattr_t *subattr; 121 122 /* 123 * Rulesets we recognize and who handles them. Additions and changes 124 * must follow the Portfolio Review process. At ths time only 125 * the FMEV_RULESET_ON_SUNOS and FMEVT_RULESET_SMF rulesets are 126 * formally recognized by that process - the others here are experimental. 127 */ 128 static struct fmevt_rs { 129 char *rs_pat; 130 fmevt_pp_func_t *rs_ppfunc; 131 char *rs_namespace; 132 char *rs_subsys; 133 } rulelist[] = { 134 { FMEV_RULESET_SMF, fmevt_pp_smf }, 135 { FMEV_RULESET_ON_EREPORT, fmevt_pp_on_ereport }, 136 { FMEV_RULESET_ON_SUNOS, fmevt_pp_on_sunos }, 137 { FMEV_RULESET_ON_PRIVATE, fmevt_pp_on_private }, 138 { FMEV_RULESET_UNREGISTERED, fmevt_pp_unregistered } 139 }; 140 141 /* 142 * Take a ruleset specification string and separate it into namespace 143 * and subsystem components. 144 */ 145 static int 146 fmevt_rs_burst(fmd_hdl_t *hdl, char *ruleset, char **nsp, char **subsysp, 147 boolean_t alloc) 148 { 149 char *ns, *s; 150 size_t len; 151 152 if (ruleset == NULL || *ruleset == '\0' || 153 strnlen(ruleset, FMEV_MAX_RULESET_LEN) == FMEV_MAX_RULESET_LEN) 154 return (0); 155 156 if (alloc == B_FALSE) { 157 s = ruleset; 158 ns = strsep(&s, FMEV_RS_SEPARATOR); 159 160 if (s == NULL || s == ns + 1) 161 return (0); 162 } else { 163 if ((s = strstr(ruleset, FMEV_RS_SEPARATOR)) == NULL || 164 s == ruleset + strlen(ruleset) - 1) 165 return (0); 166 167 len = s - ruleset; 168 169 ns = fmd_hdl_alloc(hdl, len + 1, FMD_SLEEP); 170 (void) strncpy(ns, ruleset, len); 171 ns[len] = '\0'; 172 173 s++; 174 } 175 176 if (nsp) 177 *nsp = ns; /* caller must free if alloc == B_TRUE */ 178 179 if (subsysp) 180 *subsysp = s; /* always within original ruleset string */ 181 182 return (1); 183 } 184 185 static int 186 fmevt_rs_init(fmd_hdl_t *hdl) 187 { 188 int i; 189 190 for (i = 0; i < sizeof (rulelist) / sizeof (rulelist[0]); i++) { 191 struct fmevt_rs *rsp = &rulelist[i]; 192 193 if (!fmevt_rs_burst(hdl, rsp->rs_pat, &rsp->rs_namespace, 194 &rsp->rs_subsys, B_TRUE)) 195 return (0); 196 } 197 198 return (1); 199 } 200 201 /* 202 * Construct a "sw" scheme detector FMRI. 203 * 204 * We make no use of priv or pri. 205 */ 206 /*ARGSUSED3*/ 207 static nvlist_t * 208 fmevt_detector(nvlist_t *attr, char *ruleset, int user, int priv, 209 fmev_pri_t pri) 210 { 211 char buf[FMEV_MAX_RULESET_LEN + 1]; 212 char *ns, *subsys; 213 nvlist_t *obj, *dtcr, *site, *ctxt; 214 char *execname = NULL; 215 int32_t i32; 216 int64_t i64; 217 int err = 0; 218 char *str; 219 220 (void) strncpy(buf, ruleset, sizeof (buf)); 221 if (!fmevt_rs_burst(NULL, buf, &ns, &subsys, B_FALSE)) 222 return (NULL); 223 224 obj = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP); 225 dtcr = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP); 226 site = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP); 227 ctxt = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP); 228 229 if (obj == NULL || dtcr == NULL || site == NULL || ctxt == NULL) { 230 err++; 231 goto done; 232 } 233 234 /* 235 * Build up 'object' nvlist. 236 */ 237 if (nvlist_lookup_string(attr, "__fmev_execname", &execname) == 0) 238 err += nvlist_add_string(obj, FM_FMRI_SW_OBJ_PATH, execname); 239 240 /* 241 * Build up 'site' nvlist. We should have source file and line 242 * number and, if the producer was compiled with C99, function name. 243 */ 244 if (nvlist_lookup_string(attr, "__fmev_file", &str) == 0) { 245 err += nvlist_add_string(site, FM_FMRI_SW_SITE_FILE, str); 246 (void) nvlist_remove(attr, "__fmev_file", DATA_TYPE_STRING); 247 } 248 249 if (nvlist_lookup_string(attr, "__fmev_func", &str) == 0) { 250 err += nvlist_add_string(site, FM_FMRI_SW_SITE_FUNC, str); 251 (void) nvlist_remove(attr, "__fmev_func", DATA_TYPE_STRING); 252 } 253 254 if (nvlist_lookup_int64(attr, "__fmev_line", &i64) == 0) { 255 err += nvlist_add_int64(site, FM_FMRI_SW_SITE_LINE, i64); 256 (void) nvlist_remove(attr, "__fmev_line", DATA_TYPE_INT64); 257 } 258 259 /* 260 * Build up 'context' nvlist. We do not include contract id at 261 * this time. 262 */ 263 264 err += nvlist_add_string(ctxt, FM_FMRI_SW_CTXT_ORIGIN, 265 user ? "userland" : "kernel"); 266 267 if (execname) { 268 err += nvlist_add_string(ctxt, FM_FMRI_SW_CTXT_EXECNAME, 269 execname); 270 (void) nvlist_remove(attr, "__fmev_execname", DATA_TYPE_STRING); 271 } 272 273 if (nvlist_lookup_int32(attr, "__fmev_pid", &i32) == 0) { 274 err += nvlist_add_int32(ctxt, FM_FMRI_SW_CTXT_PID, i32); 275 (void) nvlist_remove(attr, "__fmev_pid", DATA_TYPE_INT32); 276 } 277 278 if (!isglobalzone) 279 err += nvlist_add_string(ctxt, FM_FMRI_SW_CTXT_ZONE, zonename); 280 281 /* Put it all together */ 282 283 err += nvlist_add_uint8(dtcr, FM_VERSION, SW_SCHEME_VERSION0); 284 err += nvlist_add_string(dtcr, FM_FMRI_SCHEME, FM_FMRI_SCHEME_SW); 285 err += nvlist_add_nvlist(dtcr, FM_FMRI_SW_OBJ, obj); 286 err += nvlist_add_nvlist(dtcr, FM_FMRI_SW_SITE, site); 287 err += nvlist_add_nvlist(dtcr, FM_FMRI_SW_CTXT, ctxt); 288 289 done: 290 if (obj != NULL) 291 nvlist_free(obj); 292 if (site != NULL) 293 nvlist_free(site); 294 if (ctxt != NULL) 295 nvlist_free(ctxt); 296 297 if (err == 0) { 298 return (dtcr); 299 } else { 300 nvlist_free(dtcr); 301 return (NULL); 302 } 303 } 304 305 static int 306 class_ok(char *class) 307 { 308 static const char *approved[] = { 309 FM_IREPORT_CLASS ".", 310 FM_EREPORT_CLASS "." 311 }; 312 313 int i; 314 315 for (i = 0; i < sizeof (approved) / sizeof (approved[0]); i++) { 316 if (strncmp(class, approved[i], strlen(approved[i])) == 0) 317 return (1); 318 } 319 320 return (0); 321 } 322 323 static void 324 fmevt_postprocess(char *ruleset, nvlist_t *dtcr, nvlist_t *rawattr, 325 struct fmevt_ppargs *eap) 326 { 327 uint_t expected = 0, processed = 0; 328 char rs2burst[FMEV_MAX_RULESET_LEN + 1]; 329 char *class[FMEVT_FANOUT_MAX]; 330 nvlist_t *attr[FMEVT_FANOUT_MAX]; 331 fmevt_pp_func_t *dispf = NULL; 332 char buf[FMEV_MAX_CLASS]; 333 char *ns, *subsys; 334 int i, found = 0; 335 uuid_t uu; 336 337 (void) strncpy(rs2burst, ruleset, sizeof (rs2burst)); 338 if (!fmevt_rs_burst(NULL, rs2burst, &ns, &subsys, B_FALSE)) { 339 BUMPSTAT(pp_bad_ruleset); 340 return; 341 } 342 343 /* 344 * Lookup a matching rule in our table. 345 */ 346 for (i = 0; i < sizeof (rulelist) / sizeof (rulelist[0]); i++) { 347 struct fmevt_rs *rsp = &rulelist[i]; 348 349 if (*ns != '*' && *rsp->rs_namespace != '*' && 350 strcmp(ns, rsp->rs_namespace) != 0) 351 continue; 352 353 if (*subsys != '*' && *rsp->rs_subsys != '*' && 354 strcmp(subsys, rsp->rs_subsys) != 0) 355 continue; 356 357 dispf = rsp->rs_ppfunc; 358 found = 1; 359 break; 360 361 } 362 363 /* 364 * If a ruleset matches but specifies a NULL function then 365 * it's electing to drop the event. If no rule was matched 366 * then default to unregistered processing. 367 */ 368 if (dispf == NULL) { 369 if (found) { 370 BUMPSTAT(pp_explicitdrop); 371 return; 372 } else { 373 BUMPSTAT(pp_fallthrurule); 374 dispf = fmevt_pp_unregistered; 375 } 376 } 377 378 /* 379 * Clear the arrays in which class strings and attribute 380 * nvlists can be returned. Pass a pointer to our stack buffer 381 * that the callee can use for the first event class (for others 382 * it must fmd_hdl_alloc and we'll free below). We will free 383 * and nvlists that are returned. 384 */ 385 bzero(class, sizeof (class)); 386 bzero(attr, sizeof (attr)); 387 class[0] = buf; 388 389 /* 390 * Generate an event UUID which will be used for the first 391 * event generated by post-processing; if post-processing 392 * fans out into more than one event the additional events 393 * can reference this uuid (but we don't generate their 394 * UUIDs until later). 395 */ 396 uuid_generate(uu); 397 uuid_unparse(uu, eap->pp_uuidstr); 398 399 /* 400 * Call selected post-processing function. See block comment 401 * in fmevt.h for a description of this process. 402 */ 403 expected = (*dispf)(class, attr, ruleset, 404 (const nvlist_t *)dtcr, rawattr, 405 (const struct fmevt_ppargs *)eap); 406 407 if (expected > FMEVT_FANOUT_MAX) { 408 BUMPSTAT(pp_fanoutmax); 409 return; /* without freeing class and nvl - could leak */ 410 } else if (expected == 0) { 411 BUMPSTAT(pp_intldrop); 412 return; 413 } 414 415 /* 416 * Post as many events as the callback completed. 417 */ 418 for (i = 0; i < FMEVT_FANOUT_MAX; i++) { 419 char uuidstr[36 + 1]; 420 char *uuidstrp; 421 nvlist_t *nvl; 422 int err = 0; 423 424 if (class[i] == NULL) 425 continue; 426 427 if (!class_ok(class[i])) { 428 BUMPSTAT(pp_badclass); 429 continue; 430 } 431 432 if (processed++ == 0) { 433 uuidstrp = eap->pp_uuidstr; 434 } else { 435 uuid_generate(uu); 436 uuid_unparse(uu, uuidstr); 437 uuidstrp = uuidstr; 438 } 439 440 if ((nvl = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP)) == NULL) { 441 BUMPSTAT(pp_nvlallocfail); 442 continue; 443 } 444 445 err += nvlist_add_uint8(nvl, FM_VERSION, 0); 446 err += nvlist_add_string(nvl, FM_CLASS, (const char *)class[i]); 447 err += nvlist_add_string(nvl, FM_IREPORT_UUID, uuidstrp); 448 err += nvlist_add_nvlist(nvl, FM_IREPORT_DETECTOR, dtcr); 449 err += nvlist_add_string(nvl, FM_IREPORT_PRIORITY, 450 fmev_pri_string(eap->pp_pri) ? 451 fmev_pri_string(eap->pp_pri) : "?"); 452 453 if (attr[i] != NULL) 454 err += nvlist_add_nvlist(nvl, FM_IREPORT_ATTRIBUTES, 455 attr[i]); 456 457 /* 458 * If we post the event into fmd_xport_post then the 459 * transport code is responsible for freeing the nvl we 460 * posted. 461 */ 462 if (err == 0) { 463 fmd_xprt_post(fmevt_hdl, fmevt_xprt, nvl, 464 eap->pp_hrt); 465 } else { 466 BUMPSTAT(pp_nvlbuildfail); 467 nvlist_free(nvl); 468 } 469 } 470 471 if (processed != expected) 472 BUMPSTAT(pp_badreturn); 473 474 for (i = 0; i < FMEVT_FANOUT_MAX; i++) { 475 /* 476 * We provided storage for class[0] but any 477 * additional events have allocated a string. 478 */ 479 if (i > 0 && class[i] != NULL) 480 fmd_hdl_strfree(fmevt_hdl, class[i]); 481 482 /* 483 * Free all attribute lists passed in if they are not 484 * just a pointer to the raw attributes 485 */ 486 if (attr[i] != NULL && attr[i] != rawattr) 487 nvlist_free(attr[i]); 488 } 489 } 490 491 static int 492 fmevt_cb(sysevent_t *sep, void *arg) 493 { 494 char *ruleset = NULL, *rawclass, *rawsubclass; 495 uint32_t cbarg = (uint32_t)arg; 496 nvlist_t *rawattr = NULL; 497 struct fmevt_ppargs ea; 498 nvlist_t *dtcr; 499 int user, priv; 500 fmev_pri_t pri; 501 502 BUMPSTAT(raw_callbacks); 503 504 if (cbarg & ~CBF_ALL) 505 fmd_hdl_abort(fmevt_hdl, "event receipt callback with " 506 "invalid flags\n"); 507 508 user = (cbarg & CBF_USER) != 0; 509 priv = (cbarg & CBF_PRIV) != 0; 510 pri = (cbarg & CBF_HV ? FMEV_HIPRI : FMEV_LOPRI); 511 512 (void) pthread_mutex_lock(&fmevt_lock); 513 514 if (fmevt_exiting) { 515 while (fmevt_xprt_refcnt > 0) 516 (void) pthread_cond_wait(&fmevt_cv, &fmevt_lock); 517 (void) pthread_mutex_unlock(&fmevt_lock); 518 return (0); /* discard event */ 519 } 520 521 fmevt_xprt_refcnt++; 522 (void) pthread_mutex_unlock(&fmevt_lock); 523 524 ruleset = sysevent_get_vendor_name(sep); /* must free */ 525 rawclass = sysevent_get_class_name(sep); /* valid with sep */ 526 rawsubclass = sysevent_get_subclass_name(sep); /* valid with sep */ 527 528 if (sysevent_get_attr_list(sep, &rawattr) != 0) { 529 BUMPSTAT(raw_noattrlist); 530 goto done; 531 } 532 533 if ((dtcr = fmevt_detector(rawattr, ruleset, user, priv, 534 pri)) == NULL) { 535 BUMPSTAT(raw_nodetector); 536 goto done; 537 } 538 539 ea.pp_rawclass = rawclass; 540 ea.pp_rawsubclass = rawsubclass; 541 sysevent_get_time(sep, &ea.pp_hrt); 542 ea.pp_user = user; 543 ea.pp_priv = priv; 544 ea.pp_pri = pri; 545 546 fmevt_postprocess(ruleset, dtcr, rawattr, &ea); 547 nvlist_free(dtcr); 548 done: 549 (void) pthread_mutex_lock(&fmevt_lock); 550 551 if (--fmevt_xprt_refcnt == 0 && fmevt_exiting) 552 (void) pthread_cond_broadcast(&fmevt_cv); 553 554 (void) pthread_mutex_unlock(&fmevt_lock); 555 556 if (ruleset) 557 free(ruleset); 558 559 if (rawattr) 560 nvlist_free(rawattr); 561 562 return (0); /* in all cases consider the event delivered */ 563 } 564 565 void 566 fmevt_init_inbound(fmd_hdl_t *hdl) 567 { 568 char *sidpfx; 569 zoneid_t zoneid; 570 int i; 571 572 if (!fmevt_rs_init(hdl)) 573 fmd_hdl_abort(hdl, "error in fmevt_rs_init\n"); 574 575 (void) fmd_stat_create(hdl, FMD_STAT_NOALLOC, sizeof (inbound_stats) / 576 sizeof (fmd_stat_t), (fmd_stat_t *)&inbound_stats); 577 578 zoneid = getzoneid(); 579 isglobalzone = (zoneid == GLOBAL_ZONEID); 580 if (getzonenamebyid(zoneid, zonename, sizeof (zonename)) == -1) 581 fmd_hdl_abort(hdl, "getzonenamebyid failed"); 582 583 if ((subattr = sysevent_subattr_alloc()) == NULL) 584 fmd_hdl_abort(hdl, "failed to allocate subscription " 585 "attributes: %s"); 586 587 sysevent_subattr_thrcreate(subattr, fmd_doorthr_create, NULL); 588 sysevent_subattr_thrsetup(subattr, fmd_doorthr_setup, NULL); 589 590 sidpfx = fmd_prop_get_string(hdl, "sidprefix"); 591 fmevt_xprt = fmd_xprt_open(hdl, FMD_XPRT_RDONLY, NULL, NULL); 592 593 for (i = 0; i < sizeof (chaninfo) / sizeof (chaninfo[0]); i++) { 594 struct fmevt_chaninfo *cip = &chaninfo[i]; 595 char *channel = fmd_prop_get_string(hdl, cip->ci_propname); 596 int err; 597 598 if (sysevent_evc_bind(channel, &cip->ci_binding, 599 EVCH_CREAT | EVCH_HOLD_PEND_INDEF) != 0) 600 fmd_hdl_abort(hdl, "failed to bind GPEC channel for " 601 "channel %s", channel); 602 603 (void) snprintf(cip->ci_sid, sizeof (cip->ci_sid), 604 "%s_%c%c%c", sidpfx, 605 cip->ci_cbarg & CBF_USER ? 'u' : 'k', 606 cip->ci_cbarg & CBF_PRIV ? 'p' : 'n', 607 cip->ci_cbarg & CBF_HV ? 'h' : 'l'); 608 609 err = sysevent_evc_xsubscribe(cip->ci_binding, cip->ci_sid, 610 EC_ALL, fmevt_cb, (void *)cip->ci_cbarg, 611 cip->ci_sflags, subattr); 612 613 if (err == EEXIST) 614 fmd_hdl_abort(hdl, "another fmd is active on " 615 "channel %s\n", channel); 616 else if (err != 0) 617 fmd_hdl_abort(hdl, "failed to subscribe to channel %s", 618 channel); 619 620 fmd_prop_free_string(hdl, channel); 621 } 622 623 fmd_prop_free_string(hdl, sidpfx); 624 } 625 626 void 627 fmevt_fini_inbound(fmd_hdl_t *hdl) 628 { 629 int i; 630 631 for (i = 0; i < sizeof (chaninfo) / sizeof (chaninfo[0]); i++) { 632 struct fmevt_chaninfo *cip = &chaninfo[i]; 633 634 if (cip->ci_binding) { 635 (void) sysevent_evc_unsubscribe(cip->ci_binding, 636 cip->ci_sid); 637 (void) sysevent_evc_unbind(cip->ci_binding); 638 cip->ci_binding = NULL; 639 } 640 } 641 642 if (subattr) { 643 sysevent_subattr_free(subattr); 644 subattr = NULL; 645 } 646 647 if (fmevt_xprt) { 648 /* drain before destruction */ 649 (void) pthread_mutex_lock(&fmevt_lock); 650 fmevt_exiting = 1; 651 while (fmevt_xprt_refcnt > 0) 652 (void) pthread_cond_wait(&fmevt_cv, &fmevt_lock); 653 (void) pthread_mutex_unlock(&fmevt_lock); 654 655 fmd_xprt_close(hdl, fmevt_xprt); 656 } 657 658 } 659