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 * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A#include <stdio.h>
2N/A#include <fcntl.h>
2N/A#include <unistd.h>
2N/A#include <stdlib.h>
2N/A#include <strings.h>
2N/A#include <errno.h>
2N/A#include <sys/types.h>
2N/A#include <sys/sysevent.h>
2N/A#include <libsysevent.h>
2N/A#include <sys/vlds.h>
2N/A#include "libds.h"
2N/A
2N/A#define PTRTOUINT64(ptr) ((uint64_t)((uintptr_t)(ptr)))
2N/Astatic char vlds_device[] =
2N/A "/devices/virtual-devices@100/channel-devices@200/"
2N/A "virtual-domain-service@0:vlds";
2N/A
2N/Atypedef struct dslibentry {
2N/A ds_hdl_t dsl_hdl;
2N/A uint32_t dsl_flags;
2N/A uint32_t dsl_tflags;
2N/A char *dsl_service;
2N/A ds_ops_t dsl_ops;
2N/A} dslibentry_t;
2N/A
2N/A/* dsl_tflags */
2N/A#define DSL_ENTRY_INUSE 0x0001 /* handle is currently active */
2N/A
2N/A#define MIN_DSLIB_ENTRIES 64
2N/Astatic dslibentry_t *dslibtab;
2N/Astatic int ndslib;
2N/A
2N/A/*
2N/A * Lock to protect the dslibtab table. We only need to protect this
2N/A * table for those functions which actually look at or modify the table:
2N/A * service registration (ds_svc_reg/ds_clnt_reg), service unregistration
2N/A * (ds_hdl_unreg) or during callbacks (ds_recv)
2N/A */
2N/Astatic mutex_t dslib_lock;
2N/A
2N/Astatic int ds_fd = -1;
2N/A
2N/Astatic char *ds_sid_name = "vlds";
2N/A
2N/Astatic evchan_t *ds_evchan;
2N/A
2N/A/*
2N/A * Static functions internal to dslib.
2N/A */
2N/Astatic dslibentry_t *ds_hdl_to_dslibentry(ds_hdl_t hdl);
2N/Astatic dslibentry_t *ds_new_dslibentry(void);
2N/Astatic uint_t ds_service_count(char *service, boolean_t is_client);
2N/Astatic dslibentry_t *ds_lookup_dslibentry(char *service, boolean_t is_client);
2N/Astatic dslibentry_t *ds_register_dslibentry(ds_hdl_t hdl, char *service,
2N/A boolean_t is_client);
2N/Astatic void ds_free_dslibentry(dslibentry_t *dsp, int force_unreg);
2N/Astatic int ds_recv(sysevent_t *sep, void *arg);
2N/Astatic void ds_string_arg(vlds_string_t *dsp, char *str);
2N/Astatic int ds_register(ds_capability_t *cap, ds_ops_t *ops, uint_t flags);
2N/A
2N/Astatic dslibentry_t *
2N/Ads_hdl_to_dslibentry(ds_hdl_t hdl)
2N/A{
2N/A int i;
2N/A dslibentry_t *dsp;
2N/A
2N/A for (i = 0, dsp = dslibtab; i < ndslib; i++, dsp++) {
2N/A if (hdl == dsp->dsl_hdl)
2N/A return (dsp);
2N/A }
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic dslibentry_t *
2N/Ads_new_dslibentry(void)
2N/A{
2N/A int newndslib;
2N/A dslibentry_t *dsp;
2N/A
2N/A if ((dsp = ds_hdl_to_dslibentry(NULL)) != NULL)
2N/A return (dsp);
2N/A
2N/A /* double the size */
2N/A newndslib = ndslib << 1;
2N/A if ((dslibtab = realloc(dslibtab, newndslib * sizeof (dslibentry_t)))
2N/A == NULL)
2N/A return (NULL);
2N/A dsp = &dslibtab[ndslib];
2N/A (void) memset(dsp, 0, (newndslib - ndslib) * sizeof (dslibentry_t));
2N/A ndslib = newndslib;
2N/A return (dsp);
2N/A}
2N/A
2N/Astatic uint_t
2N/Ads_service_count(char *service, boolean_t is_client)
2N/A{
2N/A int i;
2N/A dslibentry_t *dsp;
2N/A uint_t is_client_flag = is_client ? VLDS_REG_CLIENT : 0;
2N/A uint_t count = 0;
2N/A
2N/A for (i = 0, dsp = dslibtab; i < ndslib; i++, dsp++) {
2N/A if (dsp->dsl_hdl != NULL &&
2N/A strcmp(dsp->dsl_service, service) == 0 &&
2N/A (dsp->dsl_flags & VLDS_REG_CLIENT) == is_client_flag) {
2N/A count++;
2N/A }
2N/A }
2N/A return (count);
2N/A}
2N/A
2N/Astatic dslibentry_t *
2N/Ads_lookup_dslibentry(char *service, boolean_t is_client)
2N/A{
2N/A int i;
2N/A dslibentry_t *dsp;
2N/A uint_t is_client_flag = is_client ? VLDS_REG_CLIENT : 0;
2N/A
2N/A for (i = 0, dsp = dslibtab; i < ndslib; i++, dsp++) {
2N/A if (dsp->dsl_hdl != NULL &&
2N/A strcmp(dsp->dsl_service, service) == 0 &&
2N/A (dsp->dsl_flags & VLDS_REG_CLIENT) == is_client_flag) {
2N/A return (dsp);
2N/A }
2N/A }
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic dslibentry_t *
2N/Ads_register_dslibentry(ds_hdl_t hdl, char *service, boolean_t is_client)
2N/A{
2N/A dslibentry_t *dsp, *orig_dsp, saved_orig;
2N/A
2N/A if ((dsp = ds_hdl_to_dslibentry(hdl)) != NULL) {
2N/A dsp->dsl_tflags |= DSL_ENTRY_INUSE;
2N/A return (dsp);
2N/A }
2N/A
2N/A if ((orig_dsp = ds_lookup_dslibentry(service, is_client)) == NULL) {
2N/A return (NULL);
2N/A }
2N/A
2N/A if ((orig_dsp->dsl_tflags & DSL_ENTRY_INUSE) == 0) {
2N/A /* use the original structure entry */
2N/A orig_dsp->dsl_tflags |= DSL_ENTRY_INUSE;
2N/A orig_dsp->dsl_hdl = hdl;
2N/A return (orig_dsp);
2N/A }
2N/A
2N/A /*
2N/A * ds_new_dslibentry could cause orig_dsp to point to freed
2N/A * memory should we grow dslibtab, so save a copy of the
2N/A * table entry here and use it below.
2N/A */
2N/A saved_orig = *orig_dsp;
2N/A
2N/A /* allocate a new structure entry */
2N/A if ((dsp = ds_new_dslibentry()) == NULL)
2N/A return (NULL);
2N/A
2N/A *dsp = saved_orig;
2N/A dsp->dsl_service = strdup(saved_orig.dsl_service);
2N/A dsp->dsl_hdl = hdl;
2N/A return (dsp);
2N/A}
2N/A
2N/A/*
2N/A * Want to leave an entry in the dslib table even though all the
2N/A * handles may have been unregistered for it.
2N/A */
2N/Astatic void
2N/Ads_free_dslibentry(dslibentry_t *dsp, int force_unreg)
2N/A{
2N/A uint_t nhdls;
2N/A
2N/A /*
2N/A * Find out if we have 1 or 2 or more handles for the given
2N/A * service. Having one implies that we want to leave the entry
2N/A * intact but marked as not in use unless this is a ds_unreg_hdl
2N/A * (force_unreg is true).
2N/A */
2N/A nhdls = ds_service_count(dsp->dsl_service,
2N/A (dsp->dsl_flags & VLDS_REG_CLIENT) != 0);
2N/A
2N/A if ((nhdls == 1 && force_unreg) || nhdls >= 2) {
2N/A dsp->dsl_hdl = NULL;
2N/A if (dsp->dsl_service) {
2N/A free(dsp->dsl_service);
2N/A }
2N/A (void) memset(dsp, 0, sizeof (dslibentry_t));
2N/A } else if (nhdls == 1) {
2N/A dsp->dsl_tflags &= ~DSL_ENTRY_INUSE;
2N/A }
2N/A}
2N/A
2N/A/*ARGSUSED*/
2N/Astatic int
2N/Ads_recv(sysevent_t *sep, void *arg)
2N/A{
2N/A nvlist_t *nvl;
2N/A uint64_t hdl;
2N/A ds_ver_t ver;
2N/A ds_domain_hdl_t dhdl;
2N/A uchar_t *bufp;
2N/A boolean_t is_client;
2N/A uint_t buflen;
2N/A char *subclass;
2N/A char *servicep;
2N/A dslibentry_t *dsp;
2N/A ds_cb_arg_t cb_arg;
2N/A
2N/A subclass = sysevent_get_subclass_name(sep);
2N/A if (sysevent_get_attr_list(sep, &nvl) != 0) {
2N/A return (0);
2N/A }
2N/A
2N/A if (nvlist_lookup_uint64(nvl, VLDS_HDL, &hdl) == 0) {
2N/A if (strcmp(subclass, ESC_VLDS_REGISTER) == 0) {
2N/A void (*reg_cb)(ds_hdl_t, ds_cb_arg_t, ds_ver_t *,
2N/A ds_domain_hdl_t) = NULL;
2N/A
2N/A if (nvlist_lookup_string(nvl, VLDS_SERVICE_ID,
2N/A &servicep) == 0 &&
2N/A nvlist_lookup_boolean_value(nvl, VLDS_ISCLIENT,
2N/A &is_client) == 0) {
2N/A (void) mutex_lock(&dslib_lock);
2N/A if ((dsp = ds_register_dslibentry(hdl,
2N/A servicep, is_client)) != NULL) {
2N/A reg_cb = dsp->dsl_ops.ds_reg_cb;
2N/A cb_arg = dsp->dsl_ops.cb_arg;
2N/A }
2N/A (void) mutex_unlock(&dslib_lock);
2N/A if (reg_cb != NULL &&
2N/A nvlist_lookup_uint64(nvl, VLDS_DOMAIN_HDL,
2N/A &dhdl) == 0 &&
2N/A nvlist_lookup_uint16(nvl, VLDS_VER_MAJOR,
2N/A &ver.major) == 0 &&
2N/A nvlist_lookup_uint16(nvl, VLDS_VER_MINOR,
2N/A &ver.minor) == 0) {
2N/A (reg_cb)((ds_hdl_t)hdl, cb_arg, &ver,
2N/A dhdl);
2N/A }
2N/A }
2N/A } else if (strcmp(subclass, ESC_VLDS_UNREGISTER) == 0) {
2N/A void (*unreg_cb)(ds_hdl_t, ds_cb_arg_t) = NULL;
2N/A
2N/A (void) mutex_lock(&dslib_lock);
2N/A if ((dsp = ds_hdl_to_dslibentry(hdl)) != NULL) {
2N/A unreg_cb = dsp->dsl_ops.ds_unreg_cb;
2N/A cb_arg = dsp->dsl_ops.cb_arg;
2N/A ds_free_dslibentry(dsp, 0);
2N/A }
2N/A (void) mutex_unlock(&dslib_lock);
2N/A if (unreg_cb != NULL) {
2N/A (unreg_cb)((ds_hdl_t)hdl, cb_arg);
2N/A }
2N/A } else if (strcmp(subclass, ESC_VLDS_DATA) == 0) {
2N/A void (*data_cb)(ds_hdl_t, ds_cb_arg_t, void *,
2N/A size_t) = NULL;
2N/A
2N/A (void) mutex_lock(&dslib_lock);
2N/A if ((dsp = ds_hdl_to_dslibentry(hdl)) != NULL) {
2N/A data_cb = dsp->dsl_ops.ds_data_cb;
2N/A cb_arg = dsp->dsl_ops.cb_arg;
2N/A }
2N/A (void) mutex_unlock(&dslib_lock);
2N/A if (data_cb != NULL &&
2N/A nvlist_lookup_byte_array(nvl, VLDS_DATA, &bufp,
2N/A &buflen) == 0) {
2N/A (data_cb)((ds_hdl_t)hdl, cb_arg, bufp, buflen);
2N/A }
2N/A }
2N/A }
2N/A nvlist_free(nvl);
2N/A return (0);
2N/A}
2N/A
2N/Astatic void
2N/Ads_string_arg(vlds_string_t *dsp, char *str)
2N/A{
2N/A if (str == NULL) {
2N/A dsp->vlds_strp = NULL;
2N/A dsp->vlds_strlen = 0;
2N/A } else {
2N/A dsp->vlds_strp = PTRTOUINT64(str);
2N/A dsp->vlds_strlen = strlen(str) + 1;
2N/A }
2N/A}
2N/A
2N/Astatic int
2N/Ads_init_sysev(void)
2N/A{
2N/A char evchan_name[MAX_CHNAME_LEN];
2N/A
2N/A (void) sprintf(evchan_name, VLDS_SYSEV_CHAN_FMT, (int)getpid());
2N/A if (sysevent_evc_bind(evchan_name, &ds_evchan, 0) != 0) {
2N/A return (errno);
2N/A }
2N/A if (sysevent_evc_subscribe(ds_evchan, ds_sid_name, EC_VLDS,
2N/A ds_recv, NULL, 0) != 0) {
2N/A (void) sysevent_evc_unbind(ds_evchan);
2N/A ds_evchan = NULL;
2N/A return (errno);
2N/A }
2N/A return (0);
2N/A}
2N/A
2N/Aint
2N/Ads_init(void)
2N/A{
2N/A if (ds_fd >= 0)
2N/A return (0);
2N/A
2N/A if ((ds_fd = open(vlds_device, 0)) < 0)
2N/A return (errno);
2N/A
2N/A if (dslibtab == NULL) {
2N/A dslibtab = malloc(sizeof (dslibentry_t) * MIN_DSLIB_ENTRIES);
2N/A if (dslibtab == NULL)
2N/A return (errno = ENOMEM);
2N/A ndslib = MIN_DSLIB_ENTRIES;
2N/A (void) memset(dslibtab, 0, sizeof (dslibentry_t) * ndslib);
2N/A }
2N/A
2N/A (void) mutex_init(&dslib_lock, USYNC_THREAD, NULL);
2N/A return (0);
2N/A}
2N/A
2N/Astatic int
2N/Ads_register(ds_capability_t *cap, ds_ops_t *ops, uint_t flags)
2N/A{
2N/A dslibentry_t *dsp;
2N/A vlds_svc_reg_arg_t vlds_arg;
2N/A vlds_cap_t vlds_cap;
2N/A vlds_ver_t vlds_vers[VLDS_MAX_VERS];
2N/A uint64_t hdl_arg;
2N/A ds_hdl_t hdl;
2N/A uint_t nhdls;
2N/A int i;
2N/A
2N/A if (cap == NULL || ops == NULL || cap->svc_id == NULL ||
2N/A cap->vers == NULL || (flags & (~VLDS_REG_CLIENT)) != 0) {
2N/A return (errno = EINVAL);
2N/A }
2N/A
2N/A if (cap->nvers > VLDS_MAX_VERS) {
2N/A return (errno = EINVAL);
2N/A }
2N/A
2N/A if (ds_fd < 0 && (errno = ds_init()) != 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A if (ds_hdl_lookup(cap->svc_id, (flags & VLDS_REG_CLIENT), NULL, 1,
2N/A &nhdls) == 0 && nhdls == 1) {
2N/A return (errno = EALREADY);
2N/A }
2N/A
2N/A (void) mutex_lock(&dslib_lock);
2N/A if ((dsp = ds_new_dslibentry()) == NULL) {
2N/A (void) mutex_unlock(&dslib_lock);
2N/A return (errno = ENOMEM);
2N/A }
2N/A
2N/A /* Setup device driver capability structure. */
2N/A
2N/A /* service string */
2N/A ds_string_arg(&vlds_cap.vlds_service, cap->svc_id);
2N/A
2N/A /* version array */
2N/A for (i = 0; i < cap->nvers; i++) {
2N/A vlds_vers[i].vlds_major = cap->vers[i].major;
2N/A vlds_vers[i].vlds_minor = cap->vers[i].minor;
2N/A }
2N/A vlds_cap.vlds_versp = PTRTOUINT64(vlds_vers);
2N/A vlds_cap.vlds_nver = cap->nvers;
2N/A
2N/A /*
2N/A * Format args for VLDS_SVC_REG ioctl.
2N/A */
2N/A
2N/A vlds_arg.vlds_capp = PTRTOUINT64(&vlds_cap);
2N/A
2N/A /* op flags */
2N/A if (ops->ds_reg_cb != NULL)
2N/A flags |= VLDS_REGCB_VALID;
2N/A if (ops->ds_unreg_cb != NULL)
2N/A flags |= VLDS_UNREGCB_VALID;
2N/A if (ops->ds_data_cb != NULL)
2N/A flags |= VLDS_DATACB_VALID;
2N/A vlds_arg.vlds_reg_flags = flags;
2N/A
2N/A /* returned handle */
2N/A vlds_arg.vlds_hdlp = PTRTOUINT64(&hdl_arg);
2N/A
2N/A if (ioctl(ds_fd, VLDS_SVC_REG, &vlds_arg) < 0) {
2N/A (void) mutex_unlock(&dslib_lock);
2N/A return (errno);
2N/A }
2N/A
2N/A /*
2N/A * Setup user callback sysevent channel.
2N/A */
2N/A if ((flags & VLDS_ANYCB_VALID) != 0 && ds_evchan == NULL &&
2N/A ds_init_sysev() != 0) {
2N/A (void) mutex_unlock(&dslib_lock);
2N/A (void) ioctl(ds_fd, VLDS_UNREG_HDL, &vlds_arg);
2N/A return (errno);
2N/A }
2N/A
2N/A hdl = hdl_arg;
2N/A
2N/A /*
2N/A * Set entry values in dslibtab.
2N/A */
2N/A dsp->dsl_hdl = hdl;
2N/A dsp->dsl_flags = flags;
2N/A dsp->dsl_tflags = 0;
2N/A dsp->dsl_service = strdup(cap->svc_id);
2N/A dsp->dsl_ops = *ops;
2N/A (void) mutex_unlock(&dslib_lock);
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Registers a service provider. Kicks off the handshake with other
2N/A * domain(s) to announce servce. Callback events are as described above.
2N/A */
2N/Aint
2N/Ads_svc_reg(ds_capability_t *cap, ds_ops_t *ops)
2N/A{
2N/A return (ds_register(cap, ops, 0));
2N/A}
2N/A
2N/A/*
2N/A * Registers interest in a service from a specific domain. When that
2N/A * service is registered, the register callback is invoked. When that
2N/A * service is unregistered, the unregister callback is invoked. When
2N/A * data is received, the receive data callback is invoked.
2N/A */
2N/Aint
2N/Ads_clnt_reg(ds_capability_t *cap, ds_ops_t *ops)
2N/A{
2N/A return (ds_register(cap, ops, VLDS_REG_CLIENT));
2N/A}
2N/A
2N/A/*
2N/A * Given a service name and type, returns the existing handle(s), if
2N/A * one or more exist. This could be used to poll for the connection being
2N/A * registered or unregistered, rather than using the register/unregister
2N/A * callbacks.
2N/A */
2N/Aint
2N/Ads_hdl_lookup(char *service, boolean_t is_client, ds_hdl_t *hdlsp,
2N/A uint_t maxhdls, uint_t *nhdlsp)
2N/A{
2N/A vlds_hdl_lookup_arg_t vlds_arg;
2N/A uint64_t nhdls_arg;
2N/A
2N/A errno = 0;
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A if (service == NULL) {
2N/A return (errno = EINVAL);
2N/A }
2N/A
2N/A ds_string_arg(&vlds_arg.vlds_service, service);
2N/A vlds_arg.vlds_isclient = is_client ? VLDS_REG_CLIENT : 0;
2N/A vlds_arg.vlds_hdlsp = PTRTOUINT64(hdlsp);
2N/A vlds_arg.vlds_maxhdls = maxhdls;
2N/A vlds_arg.vlds_nhdlsp = PTRTOUINT64(&nhdls_arg);
2N/A
2N/A if (ioctl(ds_fd, VLDS_HDL_LOOKUP, &vlds_arg) < 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A *nhdlsp = nhdls_arg;
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Given a handle, return its associated domain.
2N/A */
2N/Aint
2N/Ads_domain_lookup(ds_hdl_t hdl, ds_domain_hdl_t *dhdlp)
2N/A{
2N/A vlds_dmn_lookup_arg_t vlds_arg;
2N/A uint64_t dhdl_arg;
2N/A
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A vlds_arg.vlds_hdl = hdl;
2N/A vlds_arg.vlds_dhdlp = PTRTOUINT64(&dhdl_arg);
2N/A
2N/A if (ioctl(ds_fd, VLDS_DMN_LOOKUP, &vlds_arg) < 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A if (dhdlp) {
2N/A *dhdlp = dhdl_arg;
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Unregisters either a service or an interest in that service
2N/A * indicated by the supplied handle.
2N/A */
2N/Aint
2N/Ads_unreg_hdl(ds_hdl_t hdl)
2N/A{
2N/A dslibentry_t *dsp;
2N/A vlds_unreg_hdl_arg_t vlds_arg;
2N/A
2N/A (void) mutex_lock(&dslib_lock);
2N/A if ((dsp = ds_hdl_to_dslibentry(hdl)) != NULL) {
2N/A ds_free_dslibentry(dsp, 1);
2N/A }
2N/A (void) mutex_unlock(&dslib_lock);
2N/A
2N/A if (ds_fd >= 0) {
2N/A vlds_arg.vlds_hdl = hdl;
2N/A (void) ioctl(ds_fd, VLDS_UNREG_HDL, &vlds_arg);
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Send data to the appropriate service provider or client
2N/A * indicated by the provided handle. The sender will block
2N/A * until the message has been sent. There is no guarantee
2N/A * that multiple calls to ds_send_msg by the same thread
2N/A * will result in the data showing up at the receiver in
2N/A * the same order as sent. If multiple messages are required,
2N/A * it will be up to the sender and receiver to implement a
2N/A * protocol.
2N/A */
2N/Aint
2N/Ads_send_msg(ds_hdl_t hdl, void *buf, size_t buflen)
2N/A{
2N/A vlds_send_msg_arg_t vlds_arg;
2N/A
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A vlds_arg.vlds_hdl = hdl;
2N/A vlds_arg.vlds_bufp = PTRTOUINT64(buf);
2N/A vlds_arg.vlds_buflen = buflen;
2N/A
2N/A if (ioctl(ds_fd, VLDS_SEND_MSG, &vlds_arg) < 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Receive data from the appropriate service provider or client
2N/A * indicated by the provided handle. The sender will block
2N/A * until a message has been received.
2N/A */
2N/Aint
2N/Ads_recv_msg(ds_hdl_t hdl, void *buf, size_t buflen, size_t *msglen)
2N/A{
2N/A vlds_recv_msg_arg_t vlds_arg;
2N/A uint64_t msglen_arg;
2N/A
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A vlds_arg.vlds_hdl = hdl;
2N/A vlds_arg.vlds_bufp = PTRTOUINT64(buf);
2N/A vlds_arg.vlds_buflen = buflen;
2N/A vlds_arg.vlds_msglenp = PTRTOUINT64(&msglen_arg);
2N/A
2N/A if (ioctl(ds_fd, VLDS_RECV_MSG, &vlds_arg) < 0) {
2N/A if (errno == EFBIG && msglen) {
2N/A *msglen = msglen_arg;
2N/A }
2N/A return (errno);
2N/A }
2N/A
2N/A if (msglen) {
2N/A *msglen = msglen_arg;
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Aint
2N/Ads_isready(ds_hdl_t hdl, boolean_t *is_ready)
2N/A{
2N/A vlds_hdl_isready_arg_t vlds_arg;
2N/A uint64_t is_ready_arg;
2N/A
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A vlds_arg.vlds_hdl = hdl;
2N/A vlds_arg.vlds_isreadyp = PTRTOUINT64(&is_ready_arg);
2N/A
2N/A if (ioctl(ds_fd, VLDS_HDL_ISREADY, &vlds_arg) < 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A *is_ready = (is_ready_arg != 0);
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Given a domain name, return its associated domain handle.
2N/A */
2N/Aint
2N/Ads_dom_name_to_hdl(char *domain_name, ds_domain_hdl_t *dhdlp)
2N/A{
2N/A vlds_dom_nam2hdl_arg_t vlds_arg;
2N/A uint64_t dhdl_arg;
2N/A
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A ds_string_arg(&vlds_arg.vlds_domain_name, domain_name);
2N/A vlds_arg.vlds_dhdlp = PTRTOUINT64(&dhdl_arg);
2N/A
2N/A if (ioctl(ds_fd, VLDS_DOM_NAM2HDL, &vlds_arg) < 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A if (dhdlp) {
2N/A *dhdlp = dhdl_arg;
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Given a domain handle, return its associated domain name.
2N/A */
2N/Aint
2N/Ads_dom_hdl_to_name(ds_domain_hdl_t dhdl, char *domain_name, uint_t maxnamlen)
2N/A{
2N/A vlds_dom_hdl2nam_arg_t vlds_arg;
2N/A
2N/A if (ds_fd < 0) {
2N/A return (errno = EBADF);
2N/A }
2N/A
2N/A vlds_arg.vlds_dhdl = dhdl;
2N/A vlds_arg.vlds_domain_name.vlds_strp = PTRTOUINT64(domain_name);
2N/A vlds_arg.vlds_domain_name.vlds_strlen = maxnamlen;
2N/A
2N/A if (ioctl(ds_fd, VLDS_DOM_HDL2NAM, &vlds_arg) < 0) {
2N/A return (errno);
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Avoid
2N/Ads_unreg_svc(char *service, boolean_t is_client)
2N/A{
2N/A ds_hdl_t hdl;
2N/A uint_t nhdls;
2N/A
2N/A while (ds_hdl_lookup(service, is_client, &hdl, 1, &nhdls) == 0 &&
2N/A nhdls == 1) {
2N/A (void) ds_unreg_hdl(hdl);
2N/A }
2N/A}
2N/A
2N/Avoid
2N/Ads_fini(void)
2N/A{
2N/A int i;
2N/A dslibentry_t *dsp;
2N/A
2N/A if (ds_fd >= 0) {
2N/A (void) close(ds_fd);
2N/A ds_fd = -1;
2N/A }
2N/A if (ds_evchan) {
2N/A (void) sysevent_evc_unsubscribe(ds_evchan, ds_sid_name);
2N/A (void) sysevent_evc_unbind(ds_evchan);
2N/A ds_evchan = NULL;
2N/A }
2N/A if (ndslib > 0) {
2N/A (void) mutex_lock(&dslib_lock);
2N/A for (i = 0, dsp = dslibtab; i < ndslib; i++, dsp++) {
2N/A if (dsp->dsl_hdl == NULL)
2N/A continue;
2N/A if (dsp->dsl_service) {
2N/A free(dsp->dsl_service);
2N/A }
2N/A }
2N/A free(dslibtab);
2N/A ndslib = 0;
2N/A dslibtab = NULL;
2N/A (void) mutex_unlock(&dslib_lock);
2N/A (void) mutex_destroy(&dslib_lock);
2N/A }
2N/A}