patch tsoome-feedback
6659 nvlist_free(NULL) is a no-op

   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         nvlist_free(obj);

 291         nvlist_free(site);

 292         nvlist_free(ctxt);
 293 
 294         if (err == 0) {
 295                 return (dtcr);
 296         } else {
 297                 nvlist_free(dtcr);
 298                 return (NULL);
 299         }
 300 }
 301 
 302 static int
 303 class_ok(char *class)
 304 {
 305         static const char *approved[] = {
 306                 FM_IREPORT_CLASS ".",
 307                 FM_EREPORT_CLASS "."
 308         };
 309 
 310         int i;
 311 
 312         for (i = 0; i < sizeof (approved) / sizeof (approved[0]); i++) {
 313                 if (strncmp(class, approved[i], strlen(approved[i])) == 0)
 314                         return (1);
 315         }
 316 
 317         return (0);
 318 }
 319 
 320 static void
 321 fmevt_postprocess(char *ruleset, nvlist_t *dtcr, nvlist_t *rawattr,
 322     struct fmevt_ppargs *eap)
 323 {
 324         uint_t expected = 0, processed = 0;
 325         char rs2burst[FMEV_MAX_RULESET_LEN + 1];
 326         char *class[FMEVT_FANOUT_MAX];
 327         nvlist_t *attr[FMEVT_FANOUT_MAX];
 328         fmevt_pp_func_t *dispf = NULL;
 329         char buf[FMEV_MAX_CLASS];
 330         char *ns, *subsys;
 331         int i, found = 0;
 332         uuid_t uu;
 333 
 334         (void) strncpy(rs2burst, ruleset, sizeof (rs2burst));
 335         if (!fmevt_rs_burst(NULL, rs2burst, &ns, &subsys, B_FALSE)) {
 336                 BUMPSTAT(pp_bad_ruleset);
 337                 return;
 338         }
 339 
 340         /*
 341          * Lookup a matching rule in our table.
 342          */
 343         for (i = 0; i < sizeof (rulelist) / sizeof (rulelist[0]); i++) {
 344                 struct fmevt_rs *rsp = &rulelist[i];
 345 
 346                 if (*ns != '*' && *rsp->rs_namespace != '*' &&
 347                     strcmp(ns, rsp->rs_namespace) != 0)
 348                         continue;
 349 
 350                 if (*subsys != '*' && *rsp->rs_subsys != '*' &&
 351                     strcmp(subsys, rsp->rs_subsys) != 0)
 352                         continue;
 353 
 354                 dispf = rsp->rs_ppfunc;
 355                 found = 1;
 356                 break;
 357 
 358         }
 359 
 360         /*
 361          * If a ruleset matches but specifies a NULL function then
 362          * it's electing to drop the event.  If no rule was matched
 363          * then default to unregistered processing.
 364          */
 365         if (dispf == NULL) {
 366                 if (found) {
 367                         BUMPSTAT(pp_explicitdrop);
 368                         return;
 369                 } else {
 370                         BUMPSTAT(pp_fallthrurule);
 371                         dispf = fmevt_pp_unregistered;
 372                 }
 373         }
 374 
 375         /*
 376          * Clear the arrays in which class strings and attribute
 377          * nvlists can be returned.  Pass a pointer to our stack buffer
 378          * that the callee can use for the first event class (for others
 379          * it must fmd_hdl_alloc and we'll free below).  We will free
 380          * and nvlists that are returned.
 381          */
 382         bzero(class, sizeof (class));
 383         bzero(attr, sizeof (attr));
 384         class[0] = buf;
 385 
 386         /*
 387          * Generate an event UUID which will be used for the first
 388          * event generated by post-processing; if post-processing
 389          * fans out into more than one event the additional events
 390          * can reference this uuid (but we don't generate their
 391          * UUIDs until later).
 392          */
 393         uuid_generate(uu);
 394         uuid_unparse(uu, eap->pp_uuidstr);
 395 
 396         /*
 397          * Call selected post-processing function.  See block comment
 398          * in fmevt.h for a description of this process.
 399          */
 400         expected = (*dispf)(class, attr, ruleset,
 401             (const nvlist_t *)dtcr, rawattr,
 402             (const struct fmevt_ppargs *)eap);
 403 
 404         if (expected > FMEVT_FANOUT_MAX) {
 405                 BUMPSTAT(pp_fanoutmax);
 406                 return; /* without freeing class and nvl - could leak */
 407         } else if (expected == 0) {
 408                 BUMPSTAT(pp_intldrop);
 409                 return;
 410         }
 411 
 412         /*
 413          * Post as many events as the callback completed.
 414          */
 415         for (i = 0; i < FMEVT_FANOUT_MAX; i++) {
 416                 char uuidstr[36 + 1];
 417                 char *uuidstrp;
 418                 nvlist_t *nvl;
 419                 int err = 0;
 420 
 421                 if (class[i] == NULL)
 422                         continue;
 423 
 424                 if (!class_ok(class[i])) {
 425                         BUMPSTAT(pp_badclass);
 426                         continue;
 427                 }
 428 
 429                 if (processed++ == 0) {
 430                         uuidstrp = eap->pp_uuidstr;
 431                 } else {
 432                         uuid_generate(uu);
 433                         uuid_unparse(uu, uuidstr);
 434                         uuidstrp = uuidstr;
 435                 }
 436 
 437                 if ((nvl = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP)) == NULL) {
 438                         BUMPSTAT(pp_nvlallocfail);
 439                         continue;
 440                 }
 441 
 442                 err += nvlist_add_uint8(nvl, FM_VERSION, 0);
 443                 err += nvlist_add_string(nvl, FM_CLASS, (const char *)class[i]);
 444                 err += nvlist_add_string(nvl, FM_IREPORT_UUID, uuidstrp);
 445                 err += nvlist_add_nvlist(nvl, FM_IREPORT_DETECTOR, dtcr);
 446                 err += nvlist_add_string(nvl, FM_IREPORT_PRIORITY,
 447                     fmev_pri_string(eap->pp_pri) ?
 448                     fmev_pri_string(eap->pp_pri) : "?");
 449 
 450                 if (attr[i] != NULL)
 451                         err += nvlist_add_nvlist(nvl, FM_IREPORT_ATTRIBUTES,
 452                             attr[i]);
 453 
 454                 /*
 455                  * If we post the event into fmd_xport_post then the
 456                  * transport code is responsible for freeing the nvl we
 457                  * posted.
 458                  */
 459                 if (err == 0) {
 460                         fmd_xprt_post(fmevt_hdl, fmevt_xprt, nvl,
 461                             eap->pp_hrt);
 462                 } else {
 463                         BUMPSTAT(pp_nvlbuildfail);
 464                         nvlist_free(nvl);
 465                 }
 466         }
 467 
 468         if (processed != expected)
 469                 BUMPSTAT(pp_badreturn);
 470 
 471         for (i = 0; i < FMEVT_FANOUT_MAX; i++) {
 472                 /*
 473                  * We provided storage for class[0] but any
 474                  * additional events have allocated a string.
 475                  */
 476                 if (i > 0 && class[i] != NULL)
 477                         fmd_hdl_strfree(fmevt_hdl, class[i]);
 478 
 479                 /*
 480                  * Free all attribute lists passed in if they are not
 481                  * just a pointer to the raw attributes
 482                  */
 483                 if (attr[i] != NULL && attr[i] != rawattr)
 484                         nvlist_free(attr[i]);
 485         }
 486 }
 487 
 488 static int
 489 fmevt_cb(sysevent_t *sep, void *arg)
 490 {
 491         char *ruleset = NULL, *rawclass, *rawsubclass;
 492         uint32_t cbarg = (uint32_t)arg;
 493         nvlist_t *rawattr = NULL;
 494         struct fmevt_ppargs ea;
 495         nvlist_t *dtcr;
 496         int user, priv;
 497         fmev_pri_t pri;
 498 
 499         BUMPSTAT(raw_callbacks);
 500 
 501         if (cbarg & ~CBF_ALL)
 502                 fmd_hdl_abort(fmevt_hdl, "event receipt callback with "
 503                     "invalid flags\n");
 504 
 505         user = (cbarg & CBF_USER) != 0;
 506         priv = (cbarg & CBF_PRIV) != 0;
 507         pri = (cbarg & CBF_HV ? FMEV_HIPRI : FMEV_LOPRI);
 508 
 509         (void) pthread_mutex_lock(&fmevt_lock);
 510 
 511         if (fmevt_exiting) {
 512                 while (fmevt_xprt_refcnt > 0)
 513                         (void) pthread_cond_wait(&fmevt_cv, &fmevt_lock);
 514                 (void) pthread_mutex_unlock(&fmevt_lock);
 515                 return (0);     /* discard event */
 516         }
 517 
 518         fmevt_xprt_refcnt++;
 519         (void) pthread_mutex_unlock(&fmevt_lock);
 520 
 521         ruleset = sysevent_get_vendor_name(sep);        /* must free */
 522         rawclass = sysevent_get_class_name(sep);        /* valid with sep */
 523         rawsubclass = sysevent_get_subclass_name(sep);  /* valid with sep */
 524 
 525         if (sysevent_get_attr_list(sep, &rawattr) != 0) {
 526                 BUMPSTAT(raw_noattrlist);
 527                 goto done;
 528         }
 529 
 530         if ((dtcr = fmevt_detector(rawattr, ruleset, user, priv,
 531             pri)) == NULL) {
 532                 BUMPSTAT(raw_nodetector);
 533                 goto done;
 534         }
 535 
 536         ea.pp_rawclass = rawclass;
 537         ea.pp_rawsubclass = rawsubclass;
 538         sysevent_get_time(sep, &ea.pp_hrt);
 539         ea.pp_user = user;
 540         ea.pp_priv = priv;
 541         ea.pp_pri = pri;
 542 
 543         fmevt_postprocess(ruleset, dtcr, rawattr, &ea);
 544         nvlist_free(dtcr);
 545 done:
 546         (void) pthread_mutex_lock(&fmevt_lock);
 547 
 548         if (--fmevt_xprt_refcnt == 0 && fmevt_exiting)
 549                 (void) pthread_cond_broadcast(&fmevt_cv);
 550 
 551         (void) pthread_mutex_unlock(&fmevt_lock);
 552 
 553         if (ruleset)
 554                 free(ruleset);
 555 

 556         nvlist_free(rawattr);
 557 
 558         return (0);     /* in all cases consider the event delivered */
 559 }
 560 
 561 void
 562 fmevt_init_inbound(fmd_hdl_t *hdl)
 563 {
 564         char *sidpfx;
 565         zoneid_t zoneid;
 566         int i;
 567 
 568         if (!fmevt_rs_init(hdl))
 569                 fmd_hdl_abort(hdl, "error in fmevt_rs_init\n");
 570 
 571         (void) fmd_stat_create(hdl, FMD_STAT_NOALLOC, sizeof (inbound_stats) /
 572             sizeof (fmd_stat_t), (fmd_stat_t *)&inbound_stats);
 573 
 574         zoneid = getzoneid();
 575         isglobalzone = (zoneid == GLOBAL_ZONEID);
 576         if (getzonenamebyid(zoneid, zonename, sizeof (zonename)) == -1)
 577                 fmd_hdl_abort(hdl, "getzonenamebyid failed");
 578 
 579         if ((subattr = sysevent_subattr_alloc()) == NULL)
 580                 fmd_hdl_abort(hdl, "failed to allocate subscription "
 581                     "attributes: %s");
 582 
 583         sysevent_subattr_thrcreate(subattr, fmd_doorthr_create, NULL);
 584         sysevent_subattr_thrsetup(subattr, fmd_doorthr_setup, NULL);
 585 
 586         sidpfx = fmd_prop_get_string(hdl, "sidprefix");
 587         fmevt_xprt = fmd_xprt_open(hdl, FMD_XPRT_RDONLY, NULL, NULL);
 588 
 589         for (i = 0; i < sizeof (chaninfo) / sizeof (chaninfo[0]); i++) {
 590                 struct fmevt_chaninfo *cip = &chaninfo[i];
 591                 char *channel = fmd_prop_get_string(hdl, cip->ci_propname);
 592                 int err;
 593 
 594                 if (sysevent_evc_bind(channel, &cip->ci_binding,
 595                     EVCH_CREAT | EVCH_HOLD_PEND_INDEF) != 0)
 596                         fmd_hdl_abort(hdl, "failed to bind GPEC channel for "
 597                             "channel %s", channel);
 598 
 599                 (void) snprintf(cip->ci_sid, sizeof (cip->ci_sid),
 600                     "%s_%c%c%c", sidpfx,
 601                     cip->ci_cbarg & CBF_USER ? 'u' : 'k',
 602                     cip->ci_cbarg & CBF_PRIV ? 'p' : 'n',
 603                     cip->ci_cbarg & CBF_HV ? 'h' : 'l');
 604 
 605                 err = sysevent_evc_xsubscribe(cip->ci_binding, cip->ci_sid,
 606                     EC_ALL, fmevt_cb, (void *)cip->ci_cbarg,
 607                     cip->ci_sflags, subattr);
 608 
 609                 if (err == EEXIST)
 610                         fmd_hdl_abort(hdl, "another fmd is active on "
 611                             "channel %s\n", channel);
 612                 else if (err != 0)
 613                         fmd_hdl_abort(hdl, "failed to subscribe to channel %s",
 614                             channel);
 615 
 616                 fmd_prop_free_string(hdl, channel);
 617         }
 618 
 619         fmd_prop_free_string(hdl, sidpfx);
 620 }
 621 
 622 void
 623 fmevt_fini_inbound(fmd_hdl_t *hdl)
 624 {
 625         int i;
 626 
 627         for (i = 0; i < sizeof (chaninfo) / sizeof (chaninfo[0]); i++) {
 628                 struct fmevt_chaninfo *cip = &chaninfo[i];
 629 
 630                 if (cip->ci_binding) {
 631                         (void) sysevent_evc_unsubscribe(cip->ci_binding,
 632                             cip->ci_sid);
 633                         (void) sysevent_evc_unbind(cip->ci_binding);
 634                         cip->ci_binding = NULL;
 635                 }
 636         }
 637 
 638         if (subattr) {
 639                 sysevent_subattr_free(subattr);
 640                 subattr = NULL;
 641         }
 642 
 643         if (fmevt_xprt) {
 644                 /* drain before destruction */
 645                 (void) pthread_mutex_lock(&fmevt_lock);
 646                 fmevt_exiting = 1;
 647                 while (fmevt_xprt_refcnt > 0)
 648                         (void) pthread_cond_wait(&fmevt_cv, &fmevt_lock);
 649                 (void) pthread_mutex_unlock(&fmevt_lock);
 650 
 651                 fmd_xprt_close(hdl, fmevt_xprt);
 652         }
 653 
 654 }
--- EOF ---