/*
 * 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.
 */

/*
 * Interactions with /dev/overlay
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <stropts.h>
#include <strings.h>
#include <umem.h>

#include <libvarpd_impl.h>
#include <sys/overlay_target.h>

#define	OVERLAY_PATH	"/dev/overlay"

int
libvarpd_overlay_init(varpd_impl_t *vip)
{
	vip->vdi_overlayfd = open(OVERLAY_PATH, O_RDWR | O_EXCL);
	if (vip->vdi_overlayfd == -1)
		return (errno);
	return (0);
}

void
libvarpd_overlay_fini(varpd_impl_t *vip)
{
	assert(vip->vdi_overlayfd > 0);
	if (close(vip->vdi_overlayfd) != 0)
		libvarpd_panic("failed to close /dev/overlay fd %d: %d",
		    vip->vdi_overlayfd, errno);
}

int
libvarpd_overlay_info(varpd_impl_t *vip, datalink_id_t linkid,
    overlay_plugin_dest_t *destp, uint64_t *flags, uint64_t *vnetid)
{
	overlay_targ_info_t oti;

	oti.oti_linkid = linkid;
	if (ioctl(vip->vdi_overlayfd, OVERLAY_TARG_INFO, &oti) != 0)
		return (errno);

	if (destp != NULL)
		*destp = oti.oti_needs;
	if (flags != NULL)
		*flags = oti.oti_flags;
	if (vnetid != NULL)
		*vnetid = oti.oti_vnetid;
	return (0);
}

int
libvarpd_overlay_associate(varpd_instance_t *inst)
{
	overlay_targ_associate_t ota;
	varpd_impl_t *vip = inst->vri_impl;

	bzero(&ota, sizeof (overlay_targ_associate_t));
	ota.ota_linkid = inst->vri_linkid;
	ota.ota_mode = inst->vri_mode;
	ota.ota_id = inst->vri_id;
	ota.ota_provides = inst->vri_dest;

	if (ota.ota_mode == OVERLAY_TARGET_POINT) {
		int ret;
		ret = inst->vri_plugin->vpp_ops->vpo_default(inst->vri_private,
		    &ota.ota_point);
		if (ret != VARPD_LOOKUP_OK)
			return (ret);
	}

	if (ioctl(vip->vdi_overlayfd, OVERLAY_TARG_ASSOCIATE, &ota) != 0)
		return (errno);

	return (0);
}

int
libvarpd_overlay_disassociate(varpd_instance_t *inst)
{
	overlay_targ_id_t otid;
	varpd_impl_t *vip = inst->vri_impl;

	otid.otid_linkid = inst->vri_linkid;
	if (ioctl(vip->vdi_overlayfd, OVERLAY_TARG_DISASSOCIATE, &otid) != 0)
		return (errno);
	return (0);
}

int
libvarpd_overlay_degrade_datalink(varpd_impl_t *vip, datalink_id_t linkid,
    const char *msg)
{
	overlay_targ_degrade_t otd;

	otd.otd_linkid = linkid;
	(void) strlcpy(otd.otd_buf, msg, OVERLAY_STATUS_BUFLEN);
	if (ioctl(vip->vdi_overlayfd, OVERLAY_TARG_DEGRADE, &otd) != 0)
		return (errno);
	return (0);

}

int
libvarpd_overlay_degrade(varpd_instance_t *inst, const char *msg)
{
	return (libvarpd_overlay_degrade_datalink(inst->vri_impl,
	    inst->vri_linkid, msg));
}

int
libvarpd_overlay_restore(varpd_instance_t *inst)
{
	overlay_targ_id_t otid;
	varpd_impl_t *vip = inst->vri_impl;

	otid.otid_linkid = inst->vri_linkid;
	if (ioctl(vip->vdi_overlayfd, OVERLAY_TARG_RESTORE, &otid) != 0)
		return (errno);
	return (0);
}

int
libvarpd_overlay_packet(varpd_impl_t *vip, const overlay_targ_lookup_t *otl,
    void *buf, size_t *buflen)
{
	int ret;
	overlay_targ_pkt_t otp;

	otp.otp_linkid = UINT64_MAX;
	otp.otp_reqid = otl->otl_reqid;
	otp.otp_size = *buflen;
	otp.otp_buf = buf;

	do {
		ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_PKT, &otp);
	} while (ret != 0 && errno == EINTR);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("OVERLAY_TARG_PKT ioctl efault");
	else if (ret != 0)
		ret = errno;

	if (ret == 0)
		*buflen = otp.otp_size;

	return (ret);
}

static int
libvarpd_overlay_inject_common(varpd_impl_t *vip, varpd_instance_t *inst,
    const overlay_targ_lookup_t *otl, void *buf, size_t buflen, int cmd)
{
	int ret;
	overlay_targ_pkt_t otp;

	if (otl == NULL) {
		otp.otp_linkid = inst->vri_linkid;
		otp.otp_reqid = 0;
	} else {
		otp.otp_linkid = UINT64_MAX;
		otp.otp_reqid = otl->otl_reqid;
	}
	otp.otp_size = buflen;
	otp.otp_buf = buf;

	do {
		ret = ioctl(vip->vdi_overlayfd, cmd, &otp);
	} while (ret != 0 && errno == EINTR);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("overlay_inject_common ioctl EFAULT");
	else if (ret != 0)
		ret = errno;

	return (ret);
}

int
libvarpd_overlay_inject(varpd_impl_t *vip, const overlay_targ_lookup_t *otl,
    void *buf, size_t buflen)
{
	return (libvarpd_overlay_inject_common(vip, NULL, otl, buf, buflen,
	    OVERLAY_TARG_INJECT));
}

int
libvarpd_overlay_instance_inject(varpd_instance_t *inst, void *buf,
    size_t buflen)
{
	return (libvarpd_overlay_inject_common(inst->vri_impl, inst, NULL, buf,
	    buflen, OVERLAY_TARG_INJECT));
}

int
libvarpd_overlay_resend(varpd_impl_t *vip, const overlay_targ_lookup_t *otl,
    void *buf, size_t buflen)
{
	return (libvarpd_overlay_inject_common(vip, NULL, otl, buf, buflen,
	    OVERLAY_TARG_RESEND));
}

static void
libvarpd_overlay_lookup_reply(varpd_impl_t *vip,
    const overlay_targ_lookup_t *otl, overlay_targ_resp_t *otr, int cmd)
{
	int ret;

	otr->otr_reqid = otl->otl_reqid;
	do {
		ret = ioctl(vip->vdi_overlayfd, cmd, otr);
	} while (ret != 0 && errno == EINTR);

	/*
	 * The only errors that should cause us to end up here are due to
	 * programmer errors. Arguably the EINVAL case indicates that something
	 * is a bit off; however, at this time we don't opt to kill varpd.
	 */
	if (ret != 0 && errno != EINVAL)
		libvarpd_panic("received bad errno from lookup_reply "
		    "(cmd %d): %d\n", cmd, errno);
}

static void
libvarpd_overlay_lookup_handle(varpd_impl_t *vip)
{
	int ret;
	varpd_query_t *vqp;
	overlay_targ_lookup_t *otl;
	overlay_targ_resp_t *otr;
	varpd_instance_t *inst;

	vqp = umem_cache_alloc(vip->vdi_qcache, UMEM_DEFAULT);
	otl = &vqp->vq_lookup;
	otr = &vqp->vq_response;
	/*
	 * abort doesn't really help here that much, maybe we can instead try
	 * and for a reap or something?
	 */
	if (vqp == NULL)
		libvarpd_panic("failed to allocate memory for lookup "
		    "handle..., we should not panic()");
	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_LOOKUP, otl);
	if (ret != 0 && errno != ETIME && errno != EINTR)
		libvarpd_panic("received bad errno from OVERLAY_TARG_LOOKUP: "
		    "%d", errno);

	if (ret != 0) {
		umem_cache_free(vip->vdi_qcache, vqp);
		return;
	}

	inst = (varpd_instance_t *)libvarpd_instance_lookup(
	    (varpd_handle_t *)vip, otl->otl_varpdid);
	if (inst == NULL) {
		libvarpd_overlay_lookup_reply(vip, otl, otr,
		    OVERLAY_TARG_DROP);
		umem_cache_free(vip->vdi_qcache, vqp);
		return;
	}
	vqp->vq_instance = inst;

	inst->vri_plugin->vpp_ops->vpo_lookup(inst->vri_private,
	    (varpd_query_handle_t *)vqp, otl, &otr->otr_answer);
}

/* Use "void *" for vhp here to play nicely with thr_create(). */
void *
libvarpd_overlay_lookup_run(void *vhp)
{
	varpd_impl_t *vip = (varpd_impl_t *)vhp;

	mutex_enter(&vip->vdi_lock);
	if (vip->vdi_lthr_quiesce == B_TRUE) {
		mutex_exit(&vip->vdi_lock);
		return (NULL);
	}
	vip->vdi_lthr_count++;

	for (;;) {
		mutex_exit(&vip->vdi_lock);
		libvarpd_overlay_lookup_handle(vip);
		mutex_enter(&vip->vdi_lock);
		if (vip->vdi_lthr_quiesce == B_TRUE)
			break;
	}
	assert(vip->vdi_lthr_count > 0);
	vip->vdi_lthr_count--;
	(void) cond_signal(&vip->vdi_lthr_cv);
	mutex_exit(&vip->vdi_lock);
	return (NULL);
}

void
libvarpd_overlay_lookup_quiesce(varpd_handle_t *vhp)
{
	varpd_impl_t *vip = (varpd_impl_t *)vhp;

	mutex_enter(&vip->vdi_lock);
	if (vip->vdi_lthr_count == 0) {
		mutex_exit(&vip->vdi_lock);
		return;
	}
	vip->vdi_lthr_quiesce = B_TRUE;
	while (vip->vdi_lthr_count > 0)
		(void) cond_wait(&vip->vdi_lthr_cv, &vip->vdi_lock);
	vip->vdi_lthr_quiesce = B_FALSE;
	mutex_exit(&vip->vdi_lock);
}

int
libvarpd_overlay_iter(varpd_impl_t *vip, libvarpd_overlay_iter_f func,
    void *arg)
{
	uint32_t curents = 0, i;
	size_t size;
	overlay_targ_list_t *otl;

	for (;;) {
		size = sizeof (overlay_targ_list_t) +
		    sizeof (uint32_t) * curents;
		otl = umem_alloc(size, UMEM_DEFAULT);
		if (otl == NULL)
			return (ENOMEM);

		otl->otl_nents = curents;
		if (ioctl(vip->vdi_overlayfd, OVERLAY_TARG_LIST, otl) != 0) {
			if (errno == EFAULT)
				libvarpd_panic("OVERLAY_TARG_LIST ioctl "
				    "efault");
			umem_free(otl, size);
			if (errno == EINTR)
				continue;
			else
				return (errno);
		}

		if (otl->otl_nents == curents)
			break;

		curents = otl->otl_nents;
		umem_free(otl, size);
	}

	for (i = 0; i < otl->otl_nents; i++) {
		if (func(vip, otl->otl_ents[i], arg) != 0)
			break;
	}
	umem_free(otl, size);
	return (0);
}

int
libvarpd_overlay_cache_flush(varpd_instance_t *inst)
{
	int ret;
	overlay_targ_cache_t cache;
	varpd_impl_t *vip = inst->vri_impl;

	bzero(&cache, sizeof (overlay_targ_cache_t));
	cache.otc_linkid = inst->vri_linkid;

	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_CACHE_FLUSH, &cache);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("OVERLAY_TARG_CACHE_FLUSH ioctl efault");
	else if (ret != 0)
		ret = errno;

	return (ret);
}

int
libvarpd_overlay_cache_delete(varpd_instance_t *inst, const uint8_t *key)
{
	int ret;
	overlay_targ_cache_t cache;
	varpd_impl_t *vip = inst->vri_impl;

	bzero(&cache, sizeof (overlay_targ_cache_t));
	cache.otc_linkid = inst->vri_linkid;
	bcopy(key, cache.otc_entry.otce_mac, ETHERADDRL);

	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_CACHE_REMOVE, &cache);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("OVERLAY_TARG_CACHE_REMOVE ioctl efault");
	else if (ret != 0)
		ret = errno;

	return (ret);

}

int
libvarpd_overlay_cache_get(varpd_instance_t *inst, const uint8_t *key,
    varpd_client_cache_entry_t *entry)
{
	int ret;
	overlay_targ_cache_t cache;
	varpd_impl_t *vip = inst->vri_impl;

	bzero(&cache, sizeof (overlay_targ_cache_t));
	cache.otc_linkid = inst->vri_linkid;
	bcopy(key, cache.otc_entry.otce_mac, ETHERADDRL);

	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_CACHE_GET, &cache);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("OVERLAY_TARG_CACHE_GET ioctl efault");
	else if (ret != 0)
		return (errno);

	bcopy(cache.otc_entry.otce_dest.otp_mac, &entry->vcp_mac, ETHERADDRL);
	entry->vcp_flags = cache.otc_entry.otce_flags;
	entry->vcp_ip = cache.otc_entry.otce_dest.otp_ip;
	entry->vcp_port = cache.otc_entry.otce_dest.otp_port;

	return (0);
}

int
libvarpd_overlay_cache_set(varpd_instance_t *inst, const uint8_t *key,
    const varpd_client_cache_entry_t *entry)
{
	int ret;
	overlay_targ_cache_t cache;
	varpd_impl_t *vip = inst->vri_impl;

	bzero(&cache, sizeof (overlay_targ_cache_t));
	cache.otc_linkid = inst->vri_linkid;
	bcopy(key, cache.otc_entry.otce_mac, ETHERADDRL);
	bcopy(&entry->vcp_mac, cache.otc_entry.otce_dest.otp_mac, ETHERADDRL);
	cache.otc_entry.otce_flags = entry->vcp_flags;
	cache.otc_entry.otce_dest.otp_ip = entry->vcp_ip;
	cache.otc_entry.otce_dest.otp_port = entry->vcp_port;

	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_CACHE_SET, &cache);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("OVERLAY_TARG_CACHE_SET ioctl efault");
	else if (ret != 0)
		return (errno);

	return (0);
}

int
libvarpd_overlay_cache_walk_fill(varpd_instance_t *inst, uint64_t *markerp,
    uint64_t *countp, overlay_targ_cache_entry_t *ents)
{
	int ret;
	size_t asize;
	overlay_targ_cache_iter_t *iter;
	varpd_impl_t *vip = inst->vri_impl;

	if (*countp > 200)
		return (E2BIG);

	asize = sizeof (overlay_targ_cache_iter_t) +
	    *countp * sizeof (overlay_targ_cache_entry_t);
	iter = umem_alloc(asize, UMEM_DEFAULT);
	if (iter == NULL)
		return (ENOMEM);

	iter->otci_linkid = inst->vri_linkid;
	iter->otci_marker = *markerp;
	iter->otci_count = *countp;
	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_CACHE_ITER, iter);
	if (ret != 0 && errno == EFAULT)
		libvarpd_panic("OVERLAY_TARG_CACHE_ITER ioctl efault");
	else if (ret != 0) {
		ret = errno;
		goto out;
	}

	*markerp = iter->otci_marker;
	*countp = iter->otci_count;
	bcopy(iter->otci_ents, ents,
	    *countp * sizeof (overlay_targ_cache_entry_t));
out:
	umem_free(iter, asize);
	return (ret);
}

void
libvarpd_plugin_query_reply(varpd_query_handle_t *vqh, int action)
{
	varpd_query_t *vqp = (varpd_query_t *)vqh;

	if (vqp == NULL)
		libvarpd_panic("unknown plugin passed invalid "
		    "varpd_query_handle_t");

	if (action == VARPD_LOOKUP_DROP)
		libvarpd_overlay_lookup_reply(vqp->vq_instance->vri_impl,
		    &vqp->vq_lookup, &vqp->vq_response, OVERLAY_TARG_DROP);
	else if (action == VARPD_LOOKUP_OK)
		libvarpd_overlay_lookup_reply(vqp->vq_instance->vri_impl,
		    &vqp->vq_lookup, &vqp->vq_response, OVERLAY_TARG_RESPOND);
	else
		libvarpd_panic("plugin %s passed in an invalid action: %d",
		    vqp->vq_instance->vri_plugin->vpp_name, action);

	umem_cache_free(vqp->vq_instance->vri_impl->vdi_qcache, vqp);
}

void
libvarpd_inject_varp(varpd_provider_handle_t *vph, const uint8_t *mac,
    const overlay_target_point_t *otp)
{
	int ret;
	overlay_targ_cache_t otc;
	varpd_instance_t *inst = (varpd_instance_t *)vph;
	varpd_impl_t *vip = inst->vri_impl;

	if (otp == NULL) {
		(void) libvarpd_overlay_cache_delete(inst, mac);
		return;
	}

	otc.otc_linkid = inst->vri_linkid;
	otc.otc_entry.otce_flags = 0;
	bcopy(mac, otc.otc_entry.otce_mac, ETHERADDRL);
	bcopy(otp, &otc.otc_entry.otce_dest, sizeof (overlay_target_point_t));

	ret = ioctl(vip->vdi_overlayfd, OVERLAY_TARG_CACHE_SET, &otc);
	if (ret != 0) {
		switch (errno) {
		case EBADF:
		case EFAULT:
		case ENOTSUP:
			libvarpd_panic("received bad errno from "
			    "OVERLAY_TARG_CACHE_SET: %d", errno);
		default:
			break;
		}
	}
}

void
libvarpd_fma_degrade(varpd_provider_handle_t *vph, const char *msg)
{
	int ret;
	varpd_instance_t *inst = (varpd_instance_t *)vph;

	ret = libvarpd_overlay_degrade(inst, msg);
	switch (ret) {
	case ENOENT:
	case EFAULT:
		libvarpd_panic("received bad errno from degrade ioctl: %d",
		    errno);
	default:
		break;
	}
}

void
libvarpd_fma_restore(varpd_provider_handle_t *vph)
{
	int ret;
	varpd_instance_t *inst = (varpd_instance_t *)vph;

	ret = libvarpd_overlay_restore(inst);
	switch (ret) {
	case ENOENT:
	case EFAULT:
		libvarpd_panic("received bad errno from restore ioctl: %d",
		    errno);
	default:
		break;
	}
}