/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2015 Joyent, Inc.
 */

/*
 * varpd plugin management
 */

#include <libvarpd_impl.h>
#include <errno.h>
#include <umem.h>
#include <assert.h>
#include <strings.h>
#include <dlfcn.h>
#include <link.h>
#include <stdio.h>

static varpd_impl_t *varpd_load_handle;
static const char *varpd_load_path;
static mutex_t varpd_load_lock;
static cond_t varpd_load_cv;

int
libvarpd_plugin_comparator(const void *lp, const void *rp)
{
	int ret;
	const varpd_plugin_t *lpp, *rpp;

	lpp = lp;
	rpp = rp;

	ret = strcmp(lpp->vpp_name, rpp->vpp_name);
	if (ret > 0)
		return (1);
	if (ret < 0)
		return (-1);
	return (0);
}

varpd_plugin_register_t *
libvarpd_plugin_alloc(uint_t version, int *errp)
{
	int err;
	varpd_plugin_register_t *vprp;

	if (errp == NULL)
		errp = &err;

	if (version != VARPD_VERSION_ONE) {
		(void) fprintf(stderr,
		    "unsupported registration version %u - %s\n",
		    version, varpd_load_path);
		*errp = EINVAL;
		return (NULL);
	}

	vprp = umem_alloc(sizeof (varpd_plugin_register_t), UMEM_DEFAULT);
	if (vprp == NULL) {
		(void) fprintf(stderr,
		    "failed to allocate registration handle - %s\n",
		    varpd_load_path);
		*errp = ENOMEM;
		return (NULL);
	}

	vprp->vpr_version = VARPD_VERSION_ONE;

	return (vprp);
}

void
libvarpd_plugin_free(varpd_plugin_register_t *vprp)
{
	umem_free(vprp, sizeof (varpd_plugin_register_t));
}

int
libvarpd_plugin_register(varpd_plugin_register_t *vprp)
{
	varpd_plugin_t *vpp;
	varpd_plugin_t lookup;

	vpp = umem_alloc(sizeof (varpd_plugin_t), UMEM_DEFAULT);
	if (vpp == NULL) {
		(void) fprintf(stderr,
		    "failed to allocate memory for the varpd_plugin_t - %s\n",
		    varpd_load_path);
		return (ENOMEM);
	}

	/* Watch out for an evil plugin */
	if (vprp->vpr_version != VARPD_VERSION_ONE) {
		(void) fprintf(stderr,
		    "unsupported registration version %u - %s\n",
		    vprp->vpr_version, varpd_load_path);
		return (EINVAL);
	}

	mutex_enter(&varpd_load_lock);
	if (varpd_load_handle == NULL)
		libvarpd_panic("varpd_load_handle was unexpectedly null");

	mutex_enter(&varpd_load_handle->vdi_lock);
	lookup.vpp_name = vprp->vpr_name;
	if (avl_find(&varpd_load_handle->vdi_plugins, &lookup, NULL) != NULL) {
		(void) fprintf(stderr,
		    "module already exists with requested name '%s' - %s\n",
		    vprp->vpr_name, varpd_load_path);
		mutex_exit(&varpd_load_handle->vdi_lock);
		mutex_exit(&varpd_load_lock);
		umem_free(vpp, sizeof (varpd_plugin_t));
		return (EEXIST);
	}
	vpp->vpp_name = strdup(vprp->vpr_name);
	if (vpp->vpp_name == NULL) {
		(void) fprintf(stderr,
		    "failed to allocate memory to duplicate name - %s\n",
		    varpd_load_path);
		mutex_exit(&varpd_load_handle->vdi_lock);
		mutex_exit(&varpd_load_lock);
		umem_free(vpp, sizeof (varpd_plugin_t));
		return (ENOMEM);
	}

	vpp->vpp_mode = vprp->vpr_mode;
	vpp->vpp_ops = vprp->vpr_ops;
	if (mutex_init(&vpp->vpp_lock, USYNC_THREAD | LOCK_ERRORCHECK,
	    NULL) != 0)
		libvarpd_panic("failed to create plugin's vpp_lock");
	vpp->vpp_active = 0;
	avl_add(&varpd_load_handle->vdi_plugins, vpp);
	mutex_exit(&varpd_load_handle->vdi_lock);
	mutex_exit(&varpd_load_lock);

	return (0);
}

varpd_plugin_t *
libvarpd_plugin_lookup(varpd_impl_t *vip, const char *name)
{
	varpd_plugin_t lookup, *ret;

	lookup.vpp_name = name;
	mutex_enter(&vip->vdi_lock);
	ret = avl_find(&vip->vdi_plugins, &lookup, NULL);
	mutex_exit(&vip->vdi_lock);

	return (ret);
}

/* ARGSUSED */
static int
libvarpd_plugin_load_cb(varpd_impl_t *vip, const char *path, void *unused)
{
	void *dlp;

	varpd_load_path = path;
	dlp = dlopen(path, RTLD_LOCAL | RTLD_NOW);
	if (dlp == NULL)
		(void) fprintf(stderr, "dlopen failed - %s\n", path);
	path = NULL;

	return (0);
}

int
libvarpd_plugin_load(varpd_handle_t *vph, const char *path)
{
	int ret = 0;
	varpd_impl_t *vip = (varpd_impl_t *)vph;

	if (vip == NULL || path == NULL)
		return (EINVAL);
	mutex_enter(&varpd_load_lock);
	while (varpd_load_handle != NULL)
		(void) cond_wait(&varpd_load_cv, &varpd_load_lock);
	varpd_load_handle = vip;
	mutex_exit(&varpd_load_lock);

	ret = libvarpd_dirwalk(vip, path, ".so", libvarpd_plugin_load_cb, NULL);

	mutex_enter(&varpd_load_lock);
	varpd_load_handle = NULL;
	(void) cond_signal(&varpd_load_cv);
	mutex_exit(&varpd_load_lock);

	return (ret);
}

int
libvarpd_plugin_walk(varpd_handle_t *vph, libvarpd_plugin_walk_f func,
    void *arg)
{
	varpd_impl_t *vip = (varpd_impl_t *)vph;
	varpd_plugin_t *vpp;

	mutex_enter(&vip->vdi_lock);
	for (vpp = avl_first(&vip->vdi_plugins); vpp != NULL;
	    vpp = AVL_NEXT(&vip->vdi_plugins, vpp)) {
		if (func(vph, vpp->vpp_name, arg) != 0) {
			mutex_exit(&vip->vdi_lock);
			return (1);
		}
	}
	mutex_exit(&vip->vdi_lock);
	return (0);
}

void
libvarpd_plugin_init(void)
{
	if (mutex_init(&varpd_load_lock, USYNC_THREAD | LOCK_RECURSIVE |
	    LOCK_ERRORCHECK, NULL) != 0)
		libvarpd_panic("failed to create varpd_load_lock");

	if (cond_init(&varpd_load_cv, USYNC_THREAD, NULL) != 0)
		libvarpd_panic("failed to create varpd_load_cv");

	varpd_load_handle = NULL;
}

void
libvarpd_plugin_fini(void)
{
	assert(varpd_load_handle == NULL);
	if (mutex_destroy(&varpd_load_lock) != 0)
		libvarpd_panic("failed to destroy varpd_load_lock");
	if (cond_destroy(&varpd_load_cv) != 0)
		libvarpd_panic("failed to destroy varpd_load_cv");
}

void
libvarpd_plugin_prefork(void)
{
	mutex_enter(&varpd_load_lock);
	while (varpd_load_handle != NULL)
		(void) cond_wait(&varpd_load_cv, &varpd_load_lock);
}

void
libvarpd_plugin_postfork(void)
{
	(void) cond_signal(&varpd_load_cv);
	mutex_exit(&varpd_load_lock);
}