/*
 * 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.  All rights reserved.
 */

/*
 * varpd persistence backend
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <strings.h>
#include <librename.h>
#include <md5.h>
#include <sys/sysmacros.h>
#include <dirent.h>
#include <sys/mman.h>
#include <umem.h>
#include <sys/debug.h>

#include <libvarpd_impl.h>

static uint8_t varpd_persist_magic[4] = {
	'v',
	'a',
	'r',
	'p',
};

#define	VARPD_PERSIST_MAXWRITE		4096
#define	VARPD_PERSIST_VERSION_ONE	1
#define	VARPD_PERSIST_SUFFIX		".varpd"

typedef struct varpd_persist_header {
	uint8_t		vph_magic[4];
	uint32_t	vph_version;
	uint8_t		vph_md5[16];
} varpd_persist_header_t;

void
libvarpd_persist_init(varpd_impl_t *vip)
{
	vip->vdi_persistfd = -1;
	if (rwlock_init(&vip->vdi_pfdlock, USYNC_THREAD, NULL) != 0)
		libvarpd_panic("failed to create rw vdi_pfdlock");
}

void
libvarpd_persist_fini(varpd_impl_t *vip)
{
	/*
	 * Clean up for someone that left something behind.
	 */
	if (vip->vdi_persistfd != -1) {
		if (close(vip->vdi_persistfd) != 0)
			libvarpd_panic("failed to close persist fd %d: %d",
			    vip->vdi_persistfd, errno);
		vip->vdi_persistfd = -1;
	}
	if (rwlock_destroy(&vip->vdi_pfdlock) != 0)
		libvarpd_panic("failed to destroy rw vdi_pfdlock");
}

int
libvarpd_persist_enable(varpd_handle_t *vhp, const char *rootdir)
{
	int fd;
	struct stat st;
	varpd_impl_t *vip = (varpd_impl_t *)vhp;

	fd = open(rootdir, O_RDONLY);
	if (fd < 0)
		return (errno);

	if (fstat(fd, &st) != 0) {
		int ret = errno;
		if (close(fd) != 0)
			libvarpd_panic("failed to close rootdir fd (%s) %d: %d",
			    rootdir, fd, errno);
		return (ret);
	}

	if (!S_ISDIR(st.st_mode)) {
		if (close(fd) != 0)
			libvarpd_panic("failed to close rootdir fd (%s) %d: %d",
			    rootdir, fd, errno);
		return (EINVAL);
	}


	VERIFY0(rw_wrlock(&vip->vdi_pfdlock));
	if (vip->vdi_persistfd != -1) {
		VERIFY0(rw_unlock(&vip->vdi_pfdlock));
		if (close(fd) != 0)
			libvarpd_panic("failed to close rootdir fd (%s) %d: %d",
			    rootdir, fd, errno);
		return (EEXIST);
	}
	vip->vdi_persistfd = fd;
	VERIFY0(rw_unlock(&vip->vdi_pfdlock));

	return (0);
}

static int
libvarpd_persist_write(int fd, const void *buf, size_t buflen)
{
	ssize_t ret;
	off_t off = 0;

	while (buflen > 0) {
		ret = write(fd, (void *)((uintptr_t)buf + off),
		    MIN(buflen, VARPD_PERSIST_MAXWRITE));
		if (ret == -1 && errno == EINTR)
			continue;
		if (ret == -1)
			return (errno);

		off += ret;
		buflen -= ret;
	}

	return (0);
}

static int
libvarpd_persist_nvlist(int dirfd, uint64_t id, nvlist_t *nvl)
{
	int err, fd;
	size_t size;
	varpd_persist_header_t hdr;
	librename_atomic_t *lrap;
	char *buf = NULL, *name;

	if ((err = nvlist_pack(nvl, &buf, &size, NV_ENCODE_XDR, 0)) != 0)
		return (err);

	if (asprintf(&name, "%llu%s", (unsigned long long)id, ".varpd") == -1) {
		err = errno;
		free(buf);
		return (err);
	}

	if ((err = librename_atomic_fdinit(dirfd, name, NULL, 0600, 0,
	    &lrap)) != 0) {
		free(name);
		free(buf);
		return (err);
	}

	fd = librename_atomic_fd(lrap);

	bzero(&hdr, sizeof (varpd_persist_header_t));
	bcopy(varpd_persist_magic, hdr.vph_magic, sizeof (varpd_persist_magic));
	hdr.vph_version = VARPD_PERSIST_VERSION_ONE;
	md5_calc(hdr.vph_md5, buf, size);

	if ((err = libvarpd_persist_write(fd, &hdr,
	    sizeof (varpd_persist_header_t))) != 0) {
		librename_atomic_fini(lrap);
		free(name);
		free(buf);
		return (err);
	}

	if ((err = libvarpd_persist_write(fd, buf, size)) != 0) {
		librename_atomic_fini(lrap);
		free(name);
		free(buf);
		return (err);
	}

	do {
		err = librename_atomic_commit(lrap);
	} while (err == EINTR);

	librename_atomic_fini(lrap);
	free(name);
	free(buf);
	return (err);
}

int
libvarpd_persist_instance(varpd_impl_t *vip, varpd_instance_t *inst)
{
	int err = 0;
	nvlist_t *nvl = NULL, *cvl = NULL;

	VERIFY0(rw_rdlock(&vip->vdi_pfdlock));
	/* Check if persistence exists */
	if (vip->vdi_persistfd == -1)
		goto out;

	if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0)
		goto out;

	if ((err = nvlist_alloc(&cvl, NV_UNIQUE_NAME, 0)) != 0)
		goto out;

	if ((err = nvlist_add_uint64(nvl, "vri_id", inst->vri_id)) != 0)
		goto out;

	if ((err = nvlist_add_uint32(nvl, "vri_linkid", inst->vri_linkid)) != 0)
		goto out;

	if ((err = nvlist_add_uint32(nvl, "vri_dest",
	    (uint32_t)inst->vri_dest)) != 0)
		goto out;
	if ((err = nvlist_add_uint32(nvl, "vri_mode",
	    (uint32_t)inst->vri_mode)) != 0)
		goto out;

	if ((err = nvlist_add_string(nvl, "vri_plugin",
	    inst->vri_plugin->vpp_name)) != 0)
		goto out;

	err = inst->vri_plugin->vpp_ops->vpo_save(inst->vri_private, cvl);
	if (err != 0)
		goto out;

	if ((err = nvlist_add_nvlist(nvl, "vri_private", cvl)) != 0)
		goto out;

	err = libvarpd_persist_nvlist(vip->vdi_persistfd, inst->vri_id, nvl);
out:
	nvlist_free(nvl);
	nvlist_free(cvl);
	VERIFY0(rw_unlock(&vip->vdi_pfdlock));
	return (err);
}

void
libvarpd_torch_instance(varpd_impl_t *vip, varpd_instance_t *inst)
{
	char buf[32];
	int ret;

	VERIFY0(rw_rdlock(&vip->vdi_pfdlock));
	if (vip->vdi_persistfd == -1) {
		VERIFY0(rw_unlock(&vip->vdi_pfdlock));
		return;
	}

	if (snprintf(buf, sizeof (buf), "%lld.varpd", inst->vri_id) >= 32)
		libvarpd_panic("somehow exceeded static value for "
		    "libvarpd_torch_instance buffer");

	do {
		ret = unlinkat(vip->vdi_persistfd, buf, 0);
	} while (ret == -1 && errno == EINTR);
	if (ret != 0) {
		switch (errno) {
		case ENOENT:
			break;
		default:
			libvarpd_panic("failed to unlinkat %d`%s: %s",
			    vip->vdi_persistfd, buf, strerror(errno));
		}
	}

	VERIFY0(rw_unlock(&vip->vdi_pfdlock));
}

static int
libvarpd_persist_restore_instance(varpd_impl_t *vip, nvlist_t *nvl)
{
	int err;
	nvlist_t *pvl;
	uint64_t id, flags, vid;
	uint32_t linkid, dest, mode;
	char *pluginstr;
	varpd_plugin_t *plugin;
	overlay_plugin_dest_t adest;
	varpd_instance_t *inst, lookup;

	if (nvlist_lookup_uint64(nvl, "vri_id", &id) != 0)
		return (EINVAL);

	if (nvlist_lookup_uint32(nvl, "vri_linkid", &linkid) != 0)
		return (EINVAL);

	if (nvlist_lookup_uint32(nvl, "vri_dest", &dest) != 0)
		return (EINVAL);

	if (nvlist_lookup_uint32(nvl, "vri_mode", &mode) != 0)
		return (EINVAL);

	if (nvlist_lookup_string(nvl, "vri_plugin", &pluginstr) != 0)
		return (EINVAL);

	if (nvlist_lookup_nvlist(nvl, "vri_private", &pvl) != 0)
		return (EINVAL);

	plugin = libvarpd_plugin_lookup(vip, pluginstr);
	if (plugin == NULL)
		return (EINVAL);

	if (plugin->vpp_mode != mode)
		return (EINVAL);

	if (libvarpd_overlay_info(vip, linkid, &adest, &flags, &vid) != 0)
		return (EINVAL);

	if (dest != adest)
		return (EINVAL);

	inst = umem_alloc(sizeof (varpd_instance_t), UMEM_DEFAULT);
	if (inst == NULL)
		libvarpd_panic("failed to allocate instance for restore");

	inst->vri_id = id_alloc_specific(vip->vdi_idspace, id);
	if (inst->vri_id != id) {
		umem_free(inst, sizeof (varpd_instance_t));
		return (EINVAL);
	}

	inst->vri_linkid = linkid;
	inst->vri_vnetid = vid;
	inst->vri_mode = plugin->vpp_mode;
	inst->vri_dest = dest;
	inst->vri_plugin = plugin;
	inst->vri_impl = vip;
	inst->vri_flags = 0;
	if (plugin->vpp_ops->vpo_restore(pvl, (varpd_provider_handle_t *)inst,
	    dest, &inst->vri_private) != 0) {
		id_free(vip->vdi_idspace, id);
		umem_free(inst, sizeof (varpd_instance_t));
		return (EINVAL);
	}

	if (mutex_init(&inst->vri_lock, USYNC_THREAD | LOCK_ERRORCHECK,
	    NULL) != 0)
		libvarpd_panic("failed to create vri_lock mutex");

	mutex_enter(&vip->vdi_lock);
	lookup.vri_id = inst->vri_id;
	if (avl_find(&vip->vdi_instances, &lookup, NULL) != NULL)
		libvarpd_panic("found duplicate instance with id %d",
		    lookup.vri_id);
	avl_add(&vip->vdi_instances, inst);
	lookup.vri_linkid = inst->vri_linkid;
	if (avl_find(&vip->vdi_linstances, &lookup, NULL) != NULL)
		libvarpd_panic("found duplicate linstance with id %d",
		    lookup.vri_linkid);
	avl_add(&vip->vdi_linstances, inst);
	mutex_exit(&vip->vdi_lock);

	if (plugin->vpp_ops->vpo_start(inst->vri_private) != 0) {
		libvarpd_instance_destroy((varpd_instance_handle_t *)inst);
		return (EINVAL);
	}

	if (flags & OVERLAY_TARG_INFO_F_ACTIVE)
		(void) libvarpd_overlay_disassociate(inst);

	if (libvarpd_overlay_associate(inst) != 0) {
		libvarpd_instance_destroy((varpd_instance_handle_t *)inst);
		return (EINVAL);
	}

	if (flags & OVERLAY_TARG_INFO_F_DEGRADED) {
		if ((err = libvarpd_overlay_restore(inst)) != 0) {
			libvarpd_panic("failed to restore instance %p: %d\n",
			    inst, err);
		}
	}

	mutex_enter(&inst->vri_lock);
	inst->vri_flags |= VARPD_INSTANCE_F_ACTIVATED;
	mutex_exit(&inst->vri_lock);

	return (0);
}

static int
libvarpd_persist_restore_one(varpd_impl_t *vip, int fd)
{
	int err;
	size_t fsize;
	struct stat st;
	void *buf, *datap;
	varpd_persist_header_t *hdr;
	uint8_t md5[16];
	nvlist_t *nvl;

	if (fstat(fd, &st) != 0)
		return (errno);

	if (st.st_size <= sizeof (varpd_persist_header_t))
		return (EINVAL);
	fsize = st.st_size - sizeof (varpd_persist_header_t);

	buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (buf == MAP_FAILED)
		return (errno);

	hdr = buf;
	if (bcmp(varpd_persist_magic, hdr->vph_magic,
	    sizeof (varpd_persist_magic)) != 0) {
		if (munmap(buf, st.st_size) != 0)
			libvarpd_panic("failed to munmap %p: %d", buf, errno);
		return (EINVAL);
	}

	if (hdr->vph_version != VARPD_PERSIST_VERSION_ONE) {
		if (munmap(buf, st.st_size) != 0)
			libvarpd_panic("failed to munmap %p: %d", buf, errno);
		return (EINVAL);
	}

	datap = (void *)((uintptr_t)buf + sizeof (varpd_persist_header_t));
	md5_calc(md5, datap, fsize);
	if (bcmp(md5, hdr->vph_md5, sizeof (uint8_t) * 16) != 0) {
		if (munmap(buf, st.st_size) != 0)
			libvarpd_panic("failed to munmap %p: %d", buf, errno);
		return (EINVAL);
	}

	err = nvlist_unpack(datap, fsize, &nvl, 0);
	if (munmap(buf, st.st_size) != 0)
		libvarpd_panic("failed to munmap %p: %d", buf, errno);

	if (err != 0)
		return (EINVAL);

	err = libvarpd_persist_restore_instance(vip, nvl);
	nvlist_free(nvl);
	return (err);
}

/* ARGSUSED */
static int
libvarpd_check_degrade_cb(varpd_impl_t *vip, datalink_id_t linkid, void *arg)
{
	varpd_instance_t *inst;

	mutex_enter(&vip->vdi_lock);
	for (inst = avl_first(&vip->vdi_instances); inst != NULL;
	    inst = AVL_NEXT(&vip->vdi_instances, inst)) {
		if (inst->vri_linkid == linkid) {
			mutex_exit(&vip->vdi_lock);
			return (0);
		}
	}

	mutex_exit(&vip->vdi_lock);

	(void) libvarpd_overlay_degrade_datalink(vip, linkid,
	    "no varpd instance exists");
	return (0);
}

static void
libvarpd_check_degrade(varpd_impl_t *vip)
{
	(void) libvarpd_overlay_iter(vip, libvarpd_check_degrade_cb, NULL);
}

int
libvarpd_persist_restore(varpd_handle_t *vhp)
{
	int dirfd;
	int ret = 0;
	DIR *dirp = NULL;
	struct dirent *dp;
	varpd_impl_t *vip = (varpd_impl_t *)vhp;

	VERIFY0(rw_rdlock(&vip->vdi_pfdlock));
	if ((dirfd = dup(vip->vdi_persistfd)) < 0) {
		ret = errno;
		goto out;
	}

	if ((dirp = fdopendir(dirfd)) == NULL) {
		ret = errno;
		if (close(dirfd) != 0)
			libvarpd_panic("failed to close dirfd %d: %d",
			    dirfd, errno);
		goto out;
	}

	for (;;) {
		int fd;
		uint64_t id;
		char *eptr;
		struct stat st;

		errno = 0;
		dp = readdir(dirp);
		if (dp == NULL) {
			ret = errno;
			break;
		}

		if (strcmp(dp->d_name, ".") == 0 ||
		    strcmp(dp->d_name, "..") == 0)
			continue;

		/*
		 * Leave files that we don't recognize alone. A valid file has
		 * the format `%llu.varpd`.
		 */
		errno = 0;
		id = strtoull(dp->d_name, &eptr, 10);
		if ((id == 0 && errno == EINVAL) ||
		    (id == ULLONG_MAX && errno == ERANGE))
			continue;

		if (strcmp(eptr, VARPD_PERSIST_SUFFIX) != 0)
			continue;

		fd = openat(vip->vdi_persistfd, dp->d_name, O_RDONLY);
		if (fd < 0) {
			ret = errno;
			break;
		}

		if (fstat(fd, &st) != 0) {
			ret = errno;
			break;
		}

		if (!S_ISREG(st.st_mode)) {
			if (close(fd) != 0)
				libvarpd_panic("failed to close fd (%s) %d: "
				    "%d\n", dp->d_name, fd, errno);
			continue;
		}

		ret = libvarpd_persist_restore_one(vip, fd);
		if (close(fd) != 0)
			libvarpd_panic("failed to close fd (%s) %d: "
			    "%d\n", dp->d_name, fd, errno);
		/*
		 * This is an invalid file. We'll unlink it to save us this
		 * trouble in the future.
		 */
		if (ret != 0) {
			if (unlinkat(vip->vdi_persistfd, dp->d_name, 0) != 0) {
				ret = errno;
				break;
			}
		}
	}

	libvarpd_check_degrade(vip);

out:
	if (dirp != NULL)
		(void) closedir(dirp);
	VERIFY0(rw_unlock(&vip->vdi_pfdlock));
	return (ret);
}

int
libvarpd_persist_disable(varpd_handle_t *vhp)
{
	varpd_impl_t *vip = (varpd_impl_t *)vhp;

	VERIFY0(rw_wrlock(&vip->vdi_pfdlock));
	if (vip->vdi_persistfd == -1) {
		mutex_exit(&vip->vdi_lock);
		VERIFY0(rw_unlock(&vip->vdi_pfdlock));
		return (ENOENT);
	}
	if (close(vip->vdi_persistfd) != 0)
		libvarpd_panic("failed to close persist fd %d: %d",
		    vip->vdi_persistfd, errno);
	vip->vdi_persistfd = -1;
	VERIFY0(rw_unlock(&vip->vdi_pfdlock));
	return (0);
}