/*
 * Copyright (C) 2012-2013, Eric Wong <normalperson@yhbt.net>
 * License: GPLv3 or later (see COPYING for details)
 */
#include "cmogstored.h"
#include "dev.h"

static int stat_prefix(struct mog_svc *svc, struct stat *sb, uint32_t mog_devid)
{
	char prefix[sizeof("/dev" MOG_STR(MOG_DEVID_MAX) "/")];
	int rc;

	assert(mog_devid <= MOG_DEVID_MAX && "mog_devid not filtered");
	rc = snprintf(prefix, sizeof(prefix), "/dev%u/", mog_devid);
	assert(rc > 0 && rc < (int)sizeof(prefix) && "we suck at snprintf");

	return mog_stat(svc, prefix, sb);
}

static struct mog_dev *mog_dev_new(struct mog_svc *svc, uint32_t mog_devid)
{
	struct mog_dev *dev;
	struct stat sb;

	/* we have no space on stack */
	if (mog_devid > MOG_DEVID_MAX)
		return NULL;

	if (stat_prefix(svc, &sb, mog_devid) < 0)
		return NULL;

	dev = mog_cachealign(sizeof(struct mog_dev));
	dev->devid = mog_devid;
	dev->st_dev = sb.st_dev;
	mog_ioq_init(&dev->fsckq, svc, 1);
	mog_ioq_init(&dev->ioq, svc, svc->thr_per_dev);

	return dev;
}

/* lookup or create mog_dev for a given mog_devid */
struct mog_dev *
mog_dev_for(struct mog_svc *svc, uint32_t mog_devid, bool update)
{
	struct mog_dev finder;
	struct mog_dev *ret;
	bool need_refresh = false;
	khint_t k;

	finder.devid = mog_devid;

	CHECK(int, 0, pthread_mutex_lock(&svc->by_mog_devid_lock));
	k = kh_get(by_mog_devid, svc->by_mog_devid, &finder);
	if (k != kh_end(svc->by_mog_devid)) { /* found */
		struct stat sb;

		ret = kh_key(svc->by_mog_devid, k);
		if (!update)
			goto out;

		/*
		 * devXXX dir existed before, but is no longer readable
		 * Possible FS/device error, it could come back, so do
		 * not remove here.
		 */
		if (stat_prefix(svc, &sb, ret->devid) < 0)
			goto out;

		/* st_dev may change due to remount, update if needed */
		ret->st_dev = sb.st_dev;
	} else { /* create a new dev */
		int rc;

		ret = mog_dev_new(svc, mog_devid);

		if (!ret)
			goto out; /* could not stat */

		kh_put(by_mog_devid, svc->by_mog_devid, ret, &rc);
		switch (rc) {
		case 0:
			assert(0 && "mog_dev existed while adding");
			abort();
		case 1: /* never-used bucket */
		case 2: /* deleted bucket */
			if (!update)
				need_refresh = true;
			break; /* OK, inserted */
		default: mog_oom();
		}
	}
out:
	CHECK(int, 0, pthread_mutex_unlock(&svc->by_mog_devid_lock));

	/* we need to get the notify thread to create new worker threads */
	if (need_refresh)
		mog_notify(MOG_NOTIFY_DEVICE_REFRESH);

	return ret;
}

static int
emit_usage(
const struct mog_dev *dev, struct mog_svc *svc, int fd, struct statvfs *v)
{
	int rc = -1;
	unsigned long long available = v->f_bavail;
	unsigned long long total = v->f_blocks - (v->f_bfree - v->f_bavail);
	unsigned long long used = v->f_blocks - v->f_bfree;
	unsigned use = (used * 100) / total + !!((used * 100) % total);
	long long now = (long long)time(NULL);
	long double mb = v->f_frsize / (long double)1024.0;
	const struct mount_entry *me;

	available *= mb;
	total *= mb;
	used *= mb;

	if (use > 100)
		use = 100;

	me = mog_mnt_acquire(dev->st_dev);
	if (me) {
		static const char usage_fmt[] =
			"available: %llu\n"
			"device: %s\n"
			"disk: %s/dev%u\n"
			"time: %lld\n"
			"total: %llu\n"
			"use: %u%%\n"
			"used: %llu\n";

		errno = 0;
		rc = dprintf(fd, usage_fmt,
			     available, me->me_devname, svc->docroot,
			     (unsigned)dev->devid, now, total, use, used);

		PRESERVE_ERRNO( mog_mnt_release(me) );
		if (rc < 0 || errno == ENOSPC) {
			PRESERVE_ERRNO(do {
				syslog(LOG_ERR, "dprintf(%s/dev%u/usage): %m",
				       svc->docroot, (unsigned)dev->devid);
			} while (0));
		}
	} else {
		syslog(LOG_ERR, "mount entry not found for %s/dev%u",
		       svc->docroot, (unsigned)dev->devid);
		errno = ENODEV;
	}

	return rc;
}

int mog_dev_mkusage(const struct mog_dev *dev, struct mog_svc *svc)
{
	struct statvfs v;
	char *usage_path;
	char *tmp_path;
	int fd = -1;

	if (!svc->mgmt_mfd)
		return 0;

	usage_path = xasprintf("/dev%u/usage", (unsigned)dev->devid);
	tmp_path = xasprintf("%s.%x", usage_path, (unsigned)getpid());

	if (mog_unlink(svc, tmp_path) < 0 && errno != ENOENT) goto out;

	errno = 0;
	fd = mog_open_put(svc, tmp_path, O_EXCL|O_CREAT);
	if (fd < 0) {
		if (mog_open_expire_retry(svc))
			fd = mog_open_put(svc, tmp_path, O_EXCL|O_CREAT);
	}
	if (fd < 0) {
		PRESERVE_ERRNO(do {
			syslog(LOG_ERR, "open(%s%s): %m",
			       svc->docroot, tmp_path);
		} while (0));
		goto out;
	}
	if (fstatvfs(fd, &v) < 0) {
		PRESERVE_ERRNO(do {
			syslog(LOG_ERR, "fstatvfs(%s%s): %m",
			       svc->docroot, tmp_path);
		} while (0));
		goto out;
	}
	if (emit_usage(dev, svc, fd, &v) < 0) goto out;
	if (fchmod(fd, svc->put_perms) < 0) {
		PRESERVE_ERRNO(do {
			syslog(LOG_ERR, "fchmod(%s%s): %m",
			       svc->docroot, tmp_path);
		} while (0));
		goto out;
	}

	/* skip rename on EIO if close() fails */
	if (close(fd) != 0) {
		assert(errno != EBADF && "attempted to close bad FD");
		fd = -1;
		if (errno != EINTR) {
			/* possible EIO */
			PRESERVE_ERRNO(do {
				syslog(LOG_ERR, "close(%s%s) failed: %m",
			               svc->docroot, tmp_path);
			} while (0));
			goto out;
		}
	}

	fd = -1;
	errno = 0;
	if (mog_rename(svc, tmp_path, usage_path) != 0) {
		PRESERVE_ERRNO(do {
			syslog(LOG_ERR, "rename(%s(%s => %s))",
			       svc->docroot, tmp_path, usage_path);
		} while (0));
	}
out:
	PRESERVE_ERRNO(do {
		if (errno)
			(void)mog_unlink(svc, tmp_path);
		if (fd >= 0)
			(void)mog_close(fd);
		free(tmp_path);
		free(usage_path);
	} while (0));
	return errno ? -1 : 0;
}

void mog_dev_free(struct mog_dev *dev)
{
	mog_ioq_destroy(&dev->fsckq);
	mog_ioq_destroy(&dev->ioq);
	free(dev);
}

void mog_dev_requeue_prepare(struct mog_dev *dev)
{
	mog_ioq_requeue_prepare(&dev->ioq);
	mog_ioq_requeue_prepare(&dev->fsckq);
}