2N/A/*
2N/A * CDDL HEADER START
2N/A *
2N/A * The contents of this file are subject to the terms of the
2N/A * Common Development and Distribution License (the "License").
2N/A * You may not use this file except in compliance with the License.
2N/A *
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * or http://www.opensolaris.org/os/licensing.
2N/A * See the License for the specific language governing permissions
2N/A * and limitations under the License.
2N/A *
2N/A * When distributing Covered Code, include this CDDL HEADER in each
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/A * If applicable, add the following below this CDDL HEADER, with the
2N/A * fields enclosed by brackets "[]" replaced with your own identifying
2N/A * information: Portions Copyright [yyyy] [name of copyright owner]
2N/A *
2N/A * CDDL HEADER END
2N/A */
2N/A
2N/A/*
2N/A * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A/*
2N/A * Simple-minded raw event publication from user context. See extensive
2N/A * comments in libfmevent.h. These interfaces remain Project Private -
2N/A * they have to evolve before rollout to Public levels.
2N/A *
2N/A * Events are dispatched synchronously using the GPEC sysevent mechanism.
2N/A * The caller context must therefore be one in which a sysevent_evc_publish
2N/A * (and possibly sysevent_evc_bind if not already bound) is safe. We will
2N/A * also allocate and manipulate nvlists.
2N/A *
2N/A * Since we use GPEC, which has no least privilege awareness, these interfaces
2N/A * will only work for would-be producers running as root.
2N/A *
2N/A * There is no event rate throttling applied, so we rely on producers
2N/A * to throttle themselves. A future refinement should apply mandatory
2N/A * but tuneable throttling on a per-producer basis. In this first version
2N/A * the only throttle is the publication event queue depth - we'll drop
2N/A * events when the queue is full.
2N/A *
2N/A * We can publish over four channels, for privileged/non-privileged and
2N/A * high/low priority. Since only privileged producers will work now
2N/A * (see above) we hardcode priv == B_TRUE and so only two channels are
2N/A * actually used, separating higher and lower value streams from privileged
2N/A * producers.
2N/A */
2N/A
2N/A#include <stdarg.h>
2N/A#include <unistd.h>
2N/A#include <stdlib.h>
2N/A#include <atomic.h>
2N/A#include <errno.h>
2N/A#include <pthread.h>
2N/A#include <strings.h>
2N/A
2N/A#include "fmev_impl.h"
2N/A
2N/Astatic struct {
2N/A const char *name; /* channel name */
2N/A evchan_t *binding; /* GPEC binding, once bound */
2N/A const uint32_t flags; /* flags to use in binding */
2N/A} chaninfo[] = {
2N/A { FMEV_CHAN_USER_NOPRIV_LV, NULL, 0 },
2N/A { FMEV_CHAN_USER_NOPRIV_HV, NULL, 0 },
2N/A { FMEV_CHAN_USER_PRIV_LV, NULL, EVCH_HOLD_PEND_INDEF },
2N/A { FMEV_CHAN_USER_PRIV_HV, NULL, EVCH_HOLD_PEND_INDEF}
2N/A};
2N/A
2N/A#define CHANIDX(priv, pri) (2 * ((priv) != 0) + (pri == FMEV_HIPRI))
2N/A
2N/A#define CHAN_NAME(priv, pri) (chaninfo[CHANIDX(priv, pri)].name)
2N/A#define CHAN_BINDING(priv, pri) (chaninfo[CHANIDX(priv, pri)].binding)
2N/A#define CHAN_FLAGS(priv, pri) (chaninfo[CHANIDX(priv, pri)].flags)
2N/A
2N/A/*
2N/A * Called after fork in the new child. We clear the cached event
2N/A * channel bindings which are only valid in the process that created
2N/A * them.
2N/A */
2N/Astatic void
2N/Aclear_bindings(void)
2N/A{
2N/A int i;
2N/A
2N/A for (i = 0; i < sizeof (chaninfo) / sizeof chaninfo[0]; i++)
2N/A chaninfo[i].binding = NULL;
2N/A}
2N/A
2N/A#pragma init(_fmev_publish_init)
2N/A
2N/Astatic void
2N/A_fmev_publish_init(void)
2N/A{
2N/A (void) pthread_atfork(NULL, NULL, clear_bindings);
2N/A}
2N/A
2N/Astatic evchan_t *
2N/Abind_channel(boolean_t priv, fmev_pri_t pri)
2N/A{
2N/A evchan_t **evcpp = &CHAN_BINDING(priv, pri);
2N/A evchan_t *evc;
2N/A
2N/A if (*evcpp != NULL)
2N/A return (*evcpp);
2N/A
2N/A if (sysevent_evc_bind(CHAN_NAME(priv, pri), &evc,
2N/A EVCH_CREAT | CHAN_FLAGS(priv, pri)) != 0)
2N/A return (NULL);
2N/A
2N/A if (atomic_cas_ptr(evcpp, NULL, evc) != NULL)
2N/A (void) sysevent_evc_unbind(evc);
2N/A
2N/A return (*evcpp);
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/Avrfy_ruleset(const char *ruleset)
2N/A{
2N/A if (ruleset != NULL &&
2N/A strnlen(ruleset, FMEV_MAX_RULESET_LEN) == FMEV_MAX_RULESET_LEN)
2N/A return (FMEVERR_STRING2BIG);
2N/A
2N/A return (FMEV_OK);
2N/A
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/Avrfy_class(const char *class)
2N/A{
2N/A if (class == NULL || *class == '\0')
2N/A return (FMEVERR_API);
2N/A
2N/A if (strnlen(class, FMEV_PUB_MAXCLASSLEN) == FMEV_PUB_MAXCLASSLEN)
2N/A return (FMEVERR_STRING2BIG);
2N/A
2N/A return (FMEV_OK);
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/Avrfy_subclass(const char *subclass)
2N/A{
2N/A if (subclass == NULL || *subclass == '\0')
2N/A return (FMEVERR_API);
2N/A
2N/A if (strnlen(subclass, FMEV_PUB_MAXSUBCLASSLEN) ==
2N/A FMEV_PUB_MAXSUBCLASSLEN)
2N/A return (FMEVERR_STRING2BIG);
2N/A
2N/A return (FMEV_OK);
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/Avrfy_pri(fmev_pri_t pri)
2N/A{
2N/A return (pri == FMEV_LOPRI || pri == FMEV_HIPRI ?
2N/A FMEV_OK : FMEVERR_API);
2N/A}
2N/A
2N/Aconst char *
2N/Afmev_pri_string(fmev_pri_t pri)
2N/A{
2N/A static const char *pristr[] = { "low", "high" };
2N/A
2N/A if (vrfy_pri(pri) != FMEV_OK)
2N/A return (NULL);
2N/A
2N/A return (pristr[pri - FMEV_LOPRI]);
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/Avrfy(const char **rulesetp, const char **classp, const char **subclassp,
2N/A fmev_pri_t *prip)
2N/A{
2N/A fmev_err_t rc = FMEV_OK;
2N/A
2N/A if (rulesetp && (rc = vrfy_ruleset(*rulesetp)) != FMEV_OK)
2N/A return (rc);
2N/A
2N/A if (classp && (rc = vrfy_class(*classp)) != FMEV_OK ||
2N/A subclassp && (rc = vrfy_subclass(*subclassp)) != FMEV_OK ||
2N/A prip && (rc = vrfy_pri(*prip)) != FMEV_OK)
2N/A return (rc);
2N/A
2N/A return (FMEV_OK);
2N/A}
2N/A
2N/Auint_t fmev_va2nvl_maxtuples = 100;
2N/A
2N/Afmev_err_t
2N/Ava2nvl(nvlist_t **nvlp, va_list ap, uint_t ntuples)
2N/A{
2N/A nvlist_t *nvl = NULL;
2N/A uint_t processed = 0;
2N/A char *name;
2N/A
2N/A if (ntuples == 0)
2N/A return (FMEVERR_INTERNAL);
2N/A
2N/A if ((name = va_arg(ap, char *)) == NULL || name == FMEV_ARG_TERM)
2N/A return (FMEVERR_VARARGS_MALFORMED);
2N/A
2N/A if (ntuples > fmev_va2nvl_maxtuples)
2N/A return (FMEVERR_VARARGS_TOOLONG);
2N/A
2N/A if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
2N/A return (FMEVERR_ALLOC);
2N/A
2N/A while (name != NULL && name != FMEV_ARG_TERM && processed <= ntuples) {
2N/A data_type_t type;
2N/A int err, nelem;
2N/A
2N/A type = va_arg(ap, data_type_t);
2N/A
2N/A switch (type) {
2N/A case DATA_TYPE_BYTE:
2N/A err = nvlist_add_byte(nvl, name,
2N/A va_arg(ap, uint_t));
2N/A break;
2N/A case DATA_TYPE_BYTE_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_byte_array(nvl, name,
2N/A va_arg(ap, uchar_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_BOOLEAN_VALUE:
2N/A err = nvlist_add_boolean_value(nvl, name,
2N/A va_arg(ap, boolean_t));
2N/A break;
2N/A case DATA_TYPE_BOOLEAN_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_boolean_array(nvl, name,
2N/A va_arg(ap, boolean_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_INT8:
2N/A err = nvlist_add_int8(nvl, name,
2N/A va_arg(ap, int));
2N/A break;
2N/A case DATA_TYPE_INT8_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_int8_array(nvl, name,
2N/A va_arg(ap, int8_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_UINT8:
2N/A err = nvlist_add_uint8(nvl, name,
2N/A va_arg(ap, uint_t));
2N/A break;
2N/A case DATA_TYPE_UINT8_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_uint8_array(nvl, name,
2N/A va_arg(ap, uint8_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_INT16:
2N/A err = nvlist_add_int16(nvl, name,
2N/A va_arg(ap, int));
2N/A break;
2N/A case DATA_TYPE_INT16_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_int16_array(nvl, name,
2N/A va_arg(ap, int16_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_UINT16:
2N/A err = nvlist_add_uint16(nvl, name,
2N/A va_arg(ap, uint_t));
2N/A break;
2N/A case DATA_TYPE_UINT16_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_uint16_array(nvl, name,
2N/A va_arg(ap, uint16_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_INT32:
2N/A err = nvlist_add_int32(nvl, name,
2N/A va_arg(ap, int32_t));
2N/A break;
2N/A case DATA_TYPE_INT32_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_int32_array(nvl, name,
2N/A va_arg(ap, int32_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_UINT32:
2N/A err = nvlist_add_uint32(nvl, name,
2N/A va_arg(ap, uint32_t));
2N/A break;
2N/A case DATA_TYPE_UINT32_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_uint32_array(nvl, name,
2N/A va_arg(ap, uint32_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_INT64:
2N/A err = nvlist_add_int64(nvl, name,
2N/A va_arg(ap, int64_t));
2N/A break;
2N/A case DATA_TYPE_INT64_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_int64_array(nvl, name,
2N/A va_arg(ap, int64_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_UINT64:
2N/A err = nvlist_add_uint64(nvl, name,
2N/A va_arg(ap, uint64_t));
2N/A break;
2N/A case DATA_TYPE_UINT64_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_uint64_array(nvl, name,
2N/A va_arg(ap, uint64_t *), nelem);
2N/A break;
2N/A case DATA_TYPE_STRING:
2N/A err = nvlist_add_string(nvl, name,
2N/A va_arg(ap, char *));
2N/A break;
2N/A case DATA_TYPE_STRING_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_string_array(nvl, name,
2N/A va_arg(ap, char **), nelem);
2N/A break;
2N/A case DATA_TYPE_NVLIST:
2N/A err = nvlist_add_nvlist(nvl, name,
2N/A va_arg(ap, nvlist_t *));
2N/A break;
2N/A case DATA_TYPE_NVLIST_ARRAY:
2N/A nelem = va_arg(ap, int);
2N/A err = nvlist_add_nvlist_array(nvl, name,
2N/A va_arg(ap, nvlist_t **), nelem);
2N/A break;
2N/A case DATA_TYPE_HRTIME:
2N/A err = nvlist_add_hrtime(nvl, name,
2N/A va_arg(ap, hrtime_t));
2N/A break;
2N/A case DATA_TYPE_DOUBLE:
2N/A err = nvlist_add_double(nvl, name,
2N/A va_arg(ap, double));
2N/A break;
2N/A default:
2N/A err = EINVAL;
2N/A }
2N/A
2N/A if (err)
2N/A break; /* terminate on first error */
2N/A
2N/A processed++;
2N/A name = va_arg(ap, char *);
2N/A }
2N/A
2N/A if (name != FMEV_ARG_TERM || processed != ntuples) {
2N/A *nvlp = NULL;
2N/A nvlist_free(nvl);
2N/A return (FMEVERR_VARARGS_MALFORMED);
2N/A }
2N/A
2N/A *nvlp = nvl;
2N/A return (FMEV_SUCCESS);
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/Ado_publish(const char *file, const char *func, int64_t line,
2N/A const char *ruleset, const char *class, const char *subclass,
2N/A fmev_pri_t pri, nvlist_t *nvl, uint_t ntuples, va_list ap)
2N/A{
2N/A fmev_err_t rc = FMEVERR_INTERNAL;
2N/A boolean_t priv = B_TRUE;
2N/A nvlist_t *tmpnvl = NULL;
2N/A nvlist_t *pub;
2N/A evchan_t *evc;
2N/A
2N/A if (nvl) {
2N/A ASSERT(ntuples == 0);
2N/A
2N/A /*
2N/A * Enforce NV_UNIQUE_NAME
2N/A */
2N/A if ((nvlist_nvflag(nvl) & NV_UNIQUE_NAME) != NV_UNIQUE_NAME)
2N/A return (FMEVERR_NVLIST);
2N/A
2N/A pub = nvl;
2N/A
2N/A } else if (ntuples != 0) {
2N/A fmev_err_t err;
2N/A
2N/A err = va2nvl(&tmpnvl, ap, ntuples);
2N/A if (err != FMEV_SUCCESS)
2N/A return (err);
2N/A
2N/A pub = tmpnvl;
2N/A } else {
2N/A /*
2N/A * Even if the caller has no tuples to publish (just an event
2N/A * class and subclass), we are going to add some detector
2N/A * information so we need some nvlist.
2N/A */
2N/A if (nvlist_alloc(&tmpnvl, NV_UNIQUE_NAME, 0) != 0)
2N/A return (FMEVERR_ALLOC);
2N/A
2N/A pub = tmpnvl;
2N/A }
2N/A
2N/A evc = bind_channel(priv, pri);
2N/A
2N/A if (evc == NULL) {
2N/A rc = FMEVERR_INTERNAL;
2N/A goto done;
2N/A }
2N/A
2N/A
2N/A /*
2N/A * Add detector information
2N/A */
2N/A if (file && nvlist_add_string(pub, "__fmev_file", file) != 0 ||
2N/A func && nvlist_add_string(pub, "__fmev_func", func) != 0 ||
2N/A line != -1 && nvlist_add_int64(pub, "__fmev_line", line) != 0 ||
2N/A nvlist_add_int32(pub, "__fmev_pid", getpid()) != 0 ||
2N/A nvlist_add_string(pub, "__fmev_execname", getexecname()) != 0) {
2N/A rc = FMEVERR_ALLOC;
2N/A goto done;
2N/A }
2N/A
2N/A if (ruleset == NULL)
2N/A ruleset = FMEV_RULESET_DEFAULT;
2N/A
2N/A /*
2N/A * We abuse the GPEC publication arguments as follows:
2N/A *
2N/A * GPEC argument Our usage
2N/A * -------------------- -----------------
2N/A * const char *class Raw class
2N/A * const char *subclass Raw subclass
2N/A * const char *vendor Ruleset name
2N/A * const char *pub_name Unused
2N/A * nvlist_t *attr_list Event attributes
2N/A */
2N/A rc = (sysevent_evc_publish(evc, class, subclass, ruleset, "",
2N/A pub, EVCH_NOSLEEP) == 0) ? FMEV_SUCCESS : FMEVERR_TRANSPORT;
2N/A
2N/Adone:
2N/A /* Free a passed in nvlist iff success */
2N/A if (nvl && rc == FMEV_SUCCESS)
2N/A nvlist_free(nvl);
2N/A
2N/A if (tmpnvl)
2N/A nvlist_free(tmpnvl);
2N/A
2N/A return (rc);
2N/A}
2N/A
2N/Afmev_err_t
2N/A_i_fmev_publish_nvl(
2N/A const char *file, const char *func, int64_t line,
2N/A const char *ruleset, const char *class, const char *subclass,
2N/A fmev_pri_t pri, nvlist_t *attr)
2N/A{
2N/A fmev_err_t rc;
2N/A
2N/A if ((rc = vrfy(&ruleset, &class, &subclass, &pri)) != FMEV_OK)
2N/A return (rc); /* any attr not freed */
2N/A
2N/A return (do_publish(file, func, line,
2N/A ruleset, class, subclass,
2N/A pri, attr, 0, NULL)); /* any attr freed iff success */
2N/A}
2N/A
2N/Afmev_err_t
2N/A_i_fmev_publish(
2N/A const char *file, const char *func, int64_t line,
2N/A const char *ruleset, const char *class, const char *subclass,
2N/A fmev_pri_t pri,
2N/A uint_t ntuples, ...)
2N/A{
2N/A va_list ap;
2N/A fmev_err_t rc;
2N/A
2N/A if ((rc = vrfy(&ruleset, &class, &subclass, &pri)) != FMEV_OK)
2N/A return (rc);
2N/A
2N/A if (ntuples != 0)
2N/A va_start(ap, ntuples);
2N/A
2N/A rc = do_publish(file, func, line,
2N/A ruleset, class, subclass,
2N/A pri, NULL, ntuples, ap);
2N/A
2N/A if (ntuples != 0)
2N/A va_end(ap);
2N/A
2N/A return (rc);
2N/A}
2N/A
2N/A
2N/A#pragma weak fmev_publish = _fmev_publish
2N/A#pragma weak fmev_rspublish = _fmev_rspublish
2N/A
2N/Astatic fmev_err_t
2N/A_fmev_publish(const char *class, const char *subclass, fmev_pri_t pri,
2N/A uint_t ntuples, ...)
2N/A{
2N/A fmev_err_t rc;
2N/A va_list ap;
2N/A
2N/A if ((rc = vrfy(NULL, &class, &subclass, &pri)) != FMEV_OK)
2N/A return (rc);
2N/A
2N/A if (ntuples != 0)
2N/A va_start(ap, ntuples);
2N/A
2N/A rc = do_publish(NULL, NULL, -1,
2N/A FMEV_RULESET_DEFAULT, class, subclass,
2N/A pri, NULL, ntuples, ap);
2N/A
2N/A if (ntuples != 0)
2N/A va_end(ap);
2N/A
2N/A return (rc);
2N/A}
2N/A
2N/Astatic fmev_err_t
2N/A_fmev_rspublish(const char *ruleset, const char *class, const char *subclass,
2N/A fmev_pri_t pri, uint_t ntuples, ...)
2N/A{
2N/A fmev_err_t rc;
2N/A va_list ap;
2N/A
2N/A if ((rc = vrfy(&ruleset, &class, &subclass, &pri)) != FMEV_OK)
2N/A return (rc);
2N/A
2N/A if (ntuples != 0)
2N/A va_start(ap, ntuples);
2N/A
2N/A rc = do_publish(NULL, NULL, -1,
2N/A ruleset, class, subclass,
2N/A pri, NULL, ntuples, ap);
2N/A
2N/A if (ntuples != 0)
2N/A va_end(ap);
2N/A
2N/A return (rc);
2N/A}