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         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 }
--- EOF ---