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  * Simple-minded raw event publication from user context.  See extensive
  28  * comments in libfmevent.h.  These interfaces remain Project Private -
  29  * they have to evolve before rollout to Public levels.
  30  *
  31  * Events are dispatched synchronously using the GPEC sysevent mechanism.
  32  * The caller context must therefore be one in which a sysevent_evc_publish
  33  * (and possibly sysevent_evc_bind if not already bound) is safe.  We will
  34  * also allocate and manipulate nvlists.
  35  *
  36  * Since we use GPEC, which has no least privilege awareness, these interfaces
  37  * will only work for would-be producers running as root.
  38  *
  39  * There is no event rate throttling applied, so we rely on producers
  40  * to throttle themselves.  A future refinement should apply mandatory
  41  * but tuneable throttling on a per-producer basis.  In this first version
  42  * the only throttle is the publication event queue depth - we'll drop
  43  * events when the queue is full.
  44  *
  45  * We can publish over four channels, for privileged/non-privileged and
  46  * high/low priority.  Since only privileged producers will work now
  47  * (see above) we hardcode priv == B_TRUE and so only two channels are
  48  * actually used, separating higher and lower value streams from privileged
  49  * producers.
  50  */
  51 
  52 #include <stdarg.h>
  53 #include <unistd.h>
  54 #include <stdlib.h>
  55 #include <atomic.h>
  56 #include <errno.h>
  57 #include <pthread.h>
  58 #include <strings.h>
  59 
  60 #include "fmev_impl.h"
  61 
  62 static struct {
  63         const char *name;               /* channel name */
  64         evchan_t *binding;              /* GPEC binding, once bound */
  65         const uint32_t flags;           /* flags to use in binding */
  66 } chaninfo[] = {
  67         { FMEV_CHAN_USER_NOPRIV_LV, NULL, 0 },
  68         { FMEV_CHAN_USER_NOPRIV_HV, NULL, 0 },
  69         { FMEV_CHAN_USER_PRIV_LV, NULL, EVCH_HOLD_PEND_INDEF },
  70         { FMEV_CHAN_USER_PRIV_HV, NULL, EVCH_HOLD_PEND_INDEF}
  71 };
  72 
  73 #define CHANIDX(priv, pri) (2 * ((priv) != 0) + (pri == FMEV_HIPRI))
  74 
  75 #define CHAN_NAME(priv, pri) (chaninfo[CHANIDX(priv, pri)].name)
  76 #define CHAN_BINDING(priv, pri) (chaninfo[CHANIDX(priv, pri)].binding)
  77 #define CHAN_FLAGS(priv, pri) (chaninfo[CHANIDX(priv, pri)].flags)
  78 
  79 /*
  80  * Called after fork in the new child.  We clear the cached event
  81  * channel bindings which are only valid in the process that created
  82  * them.
  83  */
  84 static void
  85 clear_bindings(void)
  86 {
  87         int i;
  88 
  89         for (i = 0; i < sizeof (chaninfo) / sizeof chaninfo[0]; i++)
  90                 chaninfo[i].binding = NULL;
  91 }
  92 
  93 #pragma init(_fmev_publish_init)
  94 
  95 static void
  96 _fmev_publish_init(void)
  97 {
  98         (void) pthread_atfork(NULL, NULL, clear_bindings);
  99 }
 100 
 101 static evchan_t *
 102 bind_channel(boolean_t priv, fmev_pri_t pri)
 103 {
 104         evchan_t **evcpp = &CHAN_BINDING(priv, pri);
 105         evchan_t *evc;
 106 
 107         if (*evcpp != NULL)
 108                 return (*evcpp);
 109 
 110         if (sysevent_evc_bind(CHAN_NAME(priv, pri), &evc,
 111             EVCH_CREAT | CHAN_FLAGS(priv, pri)) != 0)
 112                 return (NULL);
 113 
 114         if (atomic_cas_ptr(evcpp, NULL, evc) != NULL)
 115                 (void) sysevent_evc_unbind(evc);
 116 
 117         return (*evcpp);
 118 }
 119 
 120 static fmev_err_t
 121 vrfy_ruleset(const char *ruleset)
 122 {
 123         if (ruleset != NULL &&
 124             strnlen(ruleset, FMEV_MAX_RULESET_LEN) == FMEV_MAX_RULESET_LEN)
 125                 return (FMEVERR_STRING2BIG);
 126 
 127         return (FMEV_OK);
 128 
 129 }
 130 
 131 static fmev_err_t
 132 vrfy_class(const char *class)
 133 {
 134         if (class == NULL || *class == '\0')
 135                 return (FMEVERR_API);
 136 
 137         if (strnlen(class, FMEV_PUB_MAXCLASSLEN) == FMEV_PUB_MAXCLASSLEN)
 138                 return (FMEVERR_STRING2BIG);
 139 
 140         return (FMEV_OK);
 141 }
 142 
 143 static fmev_err_t
 144 vrfy_subclass(const char *subclass)
 145 {
 146         if (subclass == NULL || *subclass == '\0')
 147                 return (FMEVERR_API);
 148 
 149         if (strnlen(subclass, FMEV_PUB_MAXSUBCLASSLEN) ==
 150             FMEV_PUB_MAXSUBCLASSLEN)
 151                 return (FMEVERR_STRING2BIG);
 152 
 153         return (FMEV_OK);
 154 }
 155 
 156 static fmev_err_t
 157 vrfy_pri(fmev_pri_t pri)
 158 {
 159         return (pri == FMEV_LOPRI || pri == FMEV_HIPRI ?
 160             FMEV_OK : FMEVERR_API);
 161 }
 162 
 163 const char *
 164 fmev_pri_string(fmev_pri_t pri)
 165 {
 166         static const char *pristr[] = { "low", "high" };
 167 
 168         if (vrfy_pri(pri) != FMEV_OK)
 169                 return (NULL);
 170 
 171         return (pristr[pri - FMEV_LOPRI]);
 172 }
 173 
 174 static fmev_err_t
 175 vrfy(const char **rulesetp, const char **classp, const char **subclassp,
 176     fmev_pri_t *prip)
 177 {
 178         fmev_err_t rc = FMEV_OK;
 179 
 180         if (rulesetp && (rc = vrfy_ruleset(*rulesetp)) != FMEV_OK)
 181                 return (rc);
 182 
 183         if (classp && (rc = vrfy_class(*classp)) != FMEV_OK ||
 184             subclassp && (rc = vrfy_subclass(*subclassp)) != FMEV_OK ||
 185             prip && (rc = vrfy_pri(*prip)) != FMEV_OK)
 186                 return (rc);
 187 
 188         return (FMEV_OK);
 189 }
 190 
 191 uint_t fmev_va2nvl_maxtuples = 100;
 192 
 193 fmev_err_t
 194 va2nvl(nvlist_t **nvlp, va_list ap, uint_t ntuples)
 195 {
 196         nvlist_t *nvl = NULL;
 197         uint_t processed = 0;
 198         char *name;
 199 
 200         if (ntuples == 0)
 201                 return (FMEVERR_INTERNAL);
 202 
 203         if ((name = va_arg(ap, char *)) == NULL || name == FMEV_ARG_TERM)
 204                 return (FMEVERR_VARARGS_MALFORMED);
 205 
 206         if (ntuples > fmev_va2nvl_maxtuples)
 207                 return (FMEVERR_VARARGS_TOOLONG);
 208 
 209         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
 210                 return (FMEVERR_ALLOC);
 211 
 212         while (name != NULL && name != FMEV_ARG_TERM && processed <= ntuples) {
 213                 data_type_t type;
 214                 int err, nelem;
 215 
 216                 type = va_arg(ap, data_type_t);
 217 
 218                 switch (type) {
 219                 case DATA_TYPE_BYTE:
 220                         err = nvlist_add_byte(nvl, name,
 221                             va_arg(ap, uint_t));
 222                         break;
 223                 case DATA_TYPE_BYTE_ARRAY:
 224                         nelem = va_arg(ap, int);
 225                         err = nvlist_add_byte_array(nvl, name,
 226                             va_arg(ap, uchar_t *), nelem);
 227                         break;
 228                 case DATA_TYPE_BOOLEAN_VALUE:
 229                         err = nvlist_add_boolean_value(nvl, name,
 230                             va_arg(ap, boolean_t));
 231                         break;
 232                 case DATA_TYPE_BOOLEAN_ARRAY:
 233                         nelem = va_arg(ap, int);
 234                         err = nvlist_add_boolean_array(nvl, name,
 235                             va_arg(ap, boolean_t *), nelem);
 236                         break;
 237                 case DATA_TYPE_INT8:
 238                         err = nvlist_add_int8(nvl, name,
 239                             va_arg(ap, int));
 240                         break;
 241                 case DATA_TYPE_INT8_ARRAY:
 242                         nelem = va_arg(ap, int);
 243                         err = nvlist_add_int8_array(nvl, name,
 244                             va_arg(ap, int8_t *), nelem);
 245                         break;
 246                 case DATA_TYPE_UINT8:
 247                         err = nvlist_add_uint8(nvl, name,
 248                             va_arg(ap, uint_t));
 249                         break;
 250                 case DATA_TYPE_UINT8_ARRAY:
 251                         nelem = va_arg(ap, int);
 252                         err = nvlist_add_uint8_array(nvl, name,
 253                             va_arg(ap, uint8_t *), nelem);
 254                         break;
 255                 case DATA_TYPE_INT16:
 256                         err = nvlist_add_int16(nvl, name,
 257                             va_arg(ap, int));
 258                         break;
 259                 case DATA_TYPE_INT16_ARRAY:
 260                         nelem = va_arg(ap, int);
 261                         err = nvlist_add_int16_array(nvl, name,
 262                             va_arg(ap, int16_t *), nelem);
 263                         break;
 264                 case DATA_TYPE_UINT16:
 265                         err = nvlist_add_uint16(nvl, name,
 266                             va_arg(ap, uint_t));
 267                         break;
 268                 case DATA_TYPE_UINT16_ARRAY:
 269                         nelem = va_arg(ap, int);
 270                         err = nvlist_add_uint16_array(nvl, name,
 271                             va_arg(ap, uint16_t *), nelem);
 272                         break;
 273                 case DATA_TYPE_INT32:
 274                         err = nvlist_add_int32(nvl, name,
 275                             va_arg(ap, int32_t));
 276                         break;
 277                 case DATA_TYPE_INT32_ARRAY:
 278                         nelem = va_arg(ap, int);
 279                         err = nvlist_add_int32_array(nvl, name,
 280                             va_arg(ap, int32_t *), nelem);
 281                         break;
 282                 case DATA_TYPE_UINT32:
 283                         err = nvlist_add_uint32(nvl, name,
 284                             va_arg(ap, uint32_t));
 285                         break;
 286                 case DATA_TYPE_UINT32_ARRAY:
 287                         nelem = va_arg(ap, int);
 288                         err = nvlist_add_uint32_array(nvl, name,
 289                             va_arg(ap, uint32_t *), nelem);
 290                         break;
 291                 case DATA_TYPE_INT64:
 292                         err = nvlist_add_int64(nvl, name,
 293                             va_arg(ap, int64_t));
 294                         break;
 295                 case DATA_TYPE_INT64_ARRAY:
 296                         nelem = va_arg(ap, int);
 297                         err = nvlist_add_int64_array(nvl, name,
 298                             va_arg(ap, int64_t *), nelem);
 299                         break;
 300                 case DATA_TYPE_UINT64:
 301                         err = nvlist_add_uint64(nvl, name,
 302                             va_arg(ap, uint64_t));
 303                         break;
 304                 case DATA_TYPE_UINT64_ARRAY:
 305                         nelem = va_arg(ap, int);
 306                         err = nvlist_add_uint64_array(nvl, name,
 307                             va_arg(ap, uint64_t *), nelem);
 308                         break;
 309                 case DATA_TYPE_STRING:
 310                         err = nvlist_add_string(nvl, name,
 311                             va_arg(ap, char *));
 312                         break;
 313                 case DATA_TYPE_STRING_ARRAY:
 314                         nelem = va_arg(ap, int);
 315                         err = nvlist_add_string_array(nvl, name,
 316                             va_arg(ap, char **), nelem);
 317                         break;
 318                 case DATA_TYPE_NVLIST:
 319                         err = nvlist_add_nvlist(nvl, name,
 320                             va_arg(ap, nvlist_t *));
 321                         break;
 322                 case DATA_TYPE_NVLIST_ARRAY:
 323                         nelem = va_arg(ap, int);
 324                         err = nvlist_add_nvlist_array(nvl, name,
 325                             va_arg(ap, nvlist_t **), nelem);
 326                         break;
 327                 case DATA_TYPE_HRTIME:
 328                         err = nvlist_add_hrtime(nvl, name,
 329                             va_arg(ap, hrtime_t));
 330                         break;
 331                 case DATA_TYPE_DOUBLE:
 332                         err = nvlist_add_double(nvl, name,
 333                             va_arg(ap, double));
 334                         break;
 335                 default:
 336                         err = EINVAL;
 337                 }
 338 
 339                 if (err)
 340                         break;  /* terminate on first error */
 341 
 342                 processed++;
 343                 name = va_arg(ap, char *);
 344         }
 345 
 346         if (name != FMEV_ARG_TERM || processed != ntuples) {
 347                 *nvlp = NULL;
 348                 nvlist_free(nvl);
 349                 return (FMEVERR_VARARGS_MALFORMED);
 350         }
 351 
 352         *nvlp = nvl;
 353         return (FMEV_SUCCESS);
 354 }
 355 
 356 static fmev_err_t
 357 do_publish(const char *file, const char *func, int64_t line,
 358     const char *ruleset, const char *class, const char *subclass,
 359     fmev_pri_t pri, nvlist_t *nvl, uint_t ntuples, va_list ap)
 360 {
 361         fmev_err_t rc = FMEVERR_INTERNAL;
 362         boolean_t priv = B_TRUE;
 363         nvlist_t *tmpnvl = NULL;
 364         nvlist_t *pub;
 365         evchan_t *evc;
 366 
 367         if (nvl) {
 368                 ASSERT(ntuples == 0);
 369 
 370                 /*
 371                  * Enforce NV_UNIQUE_NAME
 372                  */
 373                 if ((nvlist_nvflag(nvl) & NV_UNIQUE_NAME) != NV_UNIQUE_NAME)
 374                         return (FMEVERR_NVLIST);
 375 
 376                 pub = nvl;
 377 
 378         } else if (ntuples != 0) {
 379                 fmev_err_t err;
 380 
 381                 err = va2nvl(&tmpnvl, ap, ntuples);
 382                 if (err != FMEV_SUCCESS)
 383                         return (err);
 384 
 385                 pub = tmpnvl;
 386         } else {
 387                 /*
 388                  * Even if the caller has no tuples to publish (just an event
 389                  * class and subclass), we are going to add some detector
 390                  * information so we need some nvlist.
 391                  */
 392                 if (nvlist_alloc(&tmpnvl, NV_UNIQUE_NAME, 0) != 0)
 393                         return (FMEVERR_ALLOC);
 394 
 395                 pub = tmpnvl;
 396         }
 397 
 398         evc = bind_channel(priv, pri);
 399 
 400         if (evc == NULL) {
 401                 rc = FMEVERR_INTERNAL;
 402                 goto done;
 403         }
 404 
 405 
 406         /*
 407          * Add detector information
 408          */
 409         if (file && nvlist_add_string(pub, "__fmev_file", file) != 0 ||
 410             func && nvlist_add_string(pub, "__fmev_func", func) != 0 ||
 411             line != -1 && nvlist_add_int64(pub, "__fmev_line", line) != 0 ||
 412             nvlist_add_int32(pub, "__fmev_pid", getpid()) != 0 ||
 413             nvlist_add_string(pub, "__fmev_execname", getexecname()) != 0) {
 414                 rc = FMEVERR_ALLOC;
 415                 goto done;
 416         }
 417 
 418         if (ruleset == NULL)
 419                 ruleset = FMEV_RULESET_DEFAULT;
 420 
 421         /*
 422          * We abuse the GPEC publication arguments as follows:
 423          *
 424          * GPEC argument        Our usage
 425          * -------------------- -----------------
 426          * const char *class    Raw class
 427          * const char *subclass Raw subclass
 428          * const char *vendor   Ruleset name
 429          * const char *pub_name Unused
 430          * nvlist_t *attr_list  Event attributes
 431          */
 432         rc = (sysevent_evc_publish(evc, class, subclass, ruleset, "",
 433             pub, EVCH_NOSLEEP) == 0) ? FMEV_SUCCESS : FMEVERR_TRANSPORT;
 434 
 435 done:
 436         /* Free a passed in nvlist iff success */
 437         if (nvl && rc == FMEV_SUCCESS)
 438                 nvlist_free(nvl);
 439 
 440         if (tmpnvl)
 441                 nvlist_free(tmpnvl);
 442 
 443         return (rc);
 444 }
 445 
 446 fmev_err_t
 447 _i_fmev_publish_nvl(
 448     const char *file, const char *func, int64_t line,
 449     const char *ruleset, const char *class, const char *subclass,
 450     fmev_pri_t pri, nvlist_t *attr)
 451 {
 452         fmev_err_t rc;
 453 
 454         if ((rc = vrfy(&ruleset, &class, &subclass, &pri)) != FMEV_OK)
 455                 return (rc);            /* any attr not freed */
 456 
 457         return (do_publish(file, func, line,
 458             ruleset, class, subclass,
 459             pri, attr, 0, NULL));       /* any attr freed iff success */
 460 }
 461 
 462 fmev_err_t
 463 _i_fmev_publish(
 464     const char *file, const char *func, int64_t line,
 465     const char *ruleset, const char *class, const char *subclass,
 466     fmev_pri_t pri,
 467     uint_t ntuples, ...)
 468 {
 469         va_list ap;
 470         fmev_err_t rc;
 471 
 472         if ((rc = vrfy(&ruleset, &class, &subclass, &pri)) != FMEV_OK)
 473                 return (rc);
 474 
 475         if (ntuples != 0)
 476                 va_start(ap, ntuples);
 477 
 478         rc = do_publish(file, func, line,
 479             ruleset, class, subclass,
 480             pri, NULL, ntuples, ap);
 481 
 482         if (ntuples != 0)
 483                 va_end(ap);
 484 
 485         return (rc);
 486 }
 487 
 488 
 489 #pragma weak fmev_publish = _fmev_publish
 490 #pragma weak fmev_rspublish = _fmev_rspublish
 491 
 492 static fmev_err_t
 493 _fmev_publish(const char *class, const char *subclass, fmev_pri_t pri,
 494     uint_t ntuples, ...)
 495 {
 496         fmev_err_t rc;
 497         va_list ap;
 498 
 499         if ((rc = vrfy(NULL, &class, &subclass, &pri)) != FMEV_OK)
 500                 return (rc);
 501 
 502         if (ntuples != 0)
 503                 va_start(ap, ntuples);
 504 
 505         rc = do_publish(NULL, NULL, -1,
 506             FMEV_RULESET_DEFAULT, class, subclass,
 507             pri, NULL, ntuples, ap);
 508 
 509         if (ntuples != 0)
 510                 va_end(ap);
 511 
 512         return (rc);
 513 }
 514 
 515 static fmev_err_t
 516 _fmev_rspublish(const char *ruleset, const char *class, const char *subclass,
 517     fmev_pri_t pri, uint_t ntuples, ...)
 518 {
 519         fmev_err_t rc;
 520         va_list ap;
 521 
 522         if ((rc = vrfy(&ruleset, &class, &subclass, &pri)) != FMEV_OK)
 523                 return (rc);
 524 
 525         if (ntuples != 0)
 526                 va_start(ap, ntuples);
 527 
 528         rc = do_publish(NULL, NULL, -1,
 529             ruleset, class, subclass,
 530             pri, NULL, ntuples, ap);
 531 
 532         if (ntuples != 0)
 533                 va_end(ap);
 534 
 535         return (rc);
 536 }
--- EOF ---