/*
 * Copyright (c) 2017 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Collects general statistics on a 10-second interval.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/kinfo.h>
#include <sys/queue.h>
#include <sys/sysctl.h>
#include <sys/kthread.h>
#include <machine/cpu.h>
#include <sys/lock.h>
#include <sys/spinlock.h>
#include <sys/kcollect.h>
#include <sys/malloc.h>

#include <sys/thread2.h>
#include <sys/spinlock2.h>

#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/vm_kern.h>
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <vm/vm_map.h>
#include <vm/vm_pager.h>
#include <vm/vm_extern.h>

#include <machine/stdarg.h>
#include <machine/smp.h>
#include <machine/clock.h>

static uint32_t kcollect_samples = -1;	/* 0 to disable */
TUNABLE_INT("kern.collect_samples", &kcollect_samples);
SYSCTL_UINT(_kern, OID_AUTO, collect_samples, CTLFLAG_RD,
	&kcollect_samples, 0, "number of 10-second samples");

static uint64_t kcollect_index;
static const char *kcollect_slots[KCOLLECT_ENTRIES];
static kcallback_t kcollect_callback[KCOLLECT_ENTRIES];
static kcollect_t kcollect_scale;
static kcollect_t *kcollect_ary;
static struct lock kcollect_lock = LOCK_INITIALIZER("kcolk", 0, 0);

MALLOC_DEFINE(M_KCOLLECT, "kcollect", "kcollect array");

int
kcollect_register(int which, const char *id, kcallback_t func, uint64_t scale)
{
	int n;

	lockmgr(&kcollect_lock, LK_EXCLUSIVE);
	if (which >= 0) {
		n = which;
	} else {
		for (n = KCOLLECT_DYNAMIC_START; n < KCOLLECT_ENTRIES; ++n) {
			if (kcollect_slots[n] == NULL)
				break;
		}
	}
	if (n < 0 || n >= KCOLLECT_ENTRIES) {
		n = -1;
	} else {
		kcollect_slots[n] = id;
		kcollect_callback[n] = func;
		kcollect_scale.data[n] = scale;
	}
	lockmgr(&kcollect_lock, LK_RELEASE);

	return n;
}

void
kcollect_unregister(int n)
{
	lockmgr(&kcollect_lock, LK_EXCLUSIVE);
	if (n >= 0 && n < KCOLLECT_ENTRIES) {
		kcollect_slots[n] = NULL;
		kcollect_callback[n] = NULL;
	}
	lockmgr(&kcollect_lock, LK_RELEASE);
}

/*
 * Typically called by a rollup function in the callback from the
 * collection thread.  Not usually called ad-hoc.  This allows a
 * subsystem to register several collection ids but only one callback
 * which populates all of them.
 */
void
kcollect_setvalue(int n, uint64_t value)
{
	uint32_t i;

	if (n >= 0 && n < KCOLLECT_ENTRIES) {
		i = kcollect_index % kcollect_samples;
		kcollect_ary[i].data[n] = value;
	}
}

/*
 * Callback to change scale adjustment, if necessary.  Certain statistics
 * have scale info available (such as KCOLLECT_SWAPANO and SWAPCAC).
 */
void
kcollect_setscale(int n, uint64_t value)
{
	if (n >= 0 && n < KCOLLECT_ENTRIES) {
		kcollect_scale.data[n] = value;
	}
}

static
void
kcollect_thread(void *dummy)
{
	uint32_t i;
	int n;

	for (;;) {
		lockmgr(&kcollect_lock, LK_EXCLUSIVE);
		i = kcollect_index % kcollect_samples;
		bzero(&kcollect_ary[i], sizeof(kcollect_ary[i]));
		crit_enter();
		kcollect_ary[i].ticks = ticks;
		getmicrotime(&kcollect_ary[i].realtime);
		crit_exit();
		for (n = 0; n < KCOLLECT_ENTRIES; ++n) {
			if (kcollect_callback[n]) {
				kcollect_ary[i].data[n] =
					kcollect_callback[n](n);
			}
		}
		cpu_sfence();
		++kcollect_index;
		lockmgr(&kcollect_lock, LK_RELEASE);
		tsleep(&dummy, 0, "sleep", hz * KCOLLECT_INTERVAL);
	}
}

/*
 * No requirements.
 */
static int
sysctl_kcollect_data(SYSCTL_HANDLER_ARGS)
{
	int error;
	uint32_t i;
	uint32_t start;
	uint64_t count;
	kcollect_t scale;
	kcollect_t id;

	if (kcollect_samples == (uint32_t)-1 ||
	    kcollect_samples == 0) {
		return EINVAL;
	}

	error = 0;
	count = kcollect_index;
	start = count % kcollect_samples;
	if (count >= kcollect_samples)
		count = kcollect_samples - 1;

	/*
	 * Sizing request
	 */
	if (req->oldptr == NULL) {
		error = SYSCTL_OUT(req, 0, sizeof(kcollect_t) * (count + 2));
		return error;
	}

	/*
	 * Output request.  We output a scale record, a string record, and
	 * N collection records.  The strings in the string record can be
	 * up to 8 characters long, and if a string is 8 characters long it
	 * will not be zero-terminated.
	 *
	 * The low byte of the scale record specifies the format.  To get
	 * the scale value shift right by 8.
	 */
	if (kcollect_ary == NULL)
		return ENOTSUP;

	lockmgr(&kcollect_lock, LK_EXCLUSIVE);
	scale = kcollect_scale;
	scale.ticks = ticks;
	scale.hz = hz;

	bzero(&id, sizeof(id));
	for (i = 0; i < KCOLLECT_ENTRIES; ++i) {
		if (kcollect_slots[i]) {
			char *ptr = (char *)&id.data[i];
			size_t len = strlen(kcollect_slots[i]);
			if (len > sizeof(id.data[0]))
				len = sizeof(id.data[0]);
			bcopy(kcollect_slots[i], ptr, len);
		}
	}
	lockmgr(&kcollect_lock, LK_RELEASE);

	error = SYSCTL_OUT(req, &scale, sizeof(scale));
	if (error == 0)
		error = SYSCTL_OUT(req, &id, sizeof(id));

	/*
	 * Start at the current entry (not yet populated) and work
	 * backwards.  This allows callers of the sysctl to acquire
	 * a lesser amount of data aligned to the most recent side of
	 * the array.
	 */
	i = start;
	while (count) {
		if (req->oldlen - req->oldidx < sizeof(kcollect_t))
			break;
		if (i == 0)
			i = kcollect_samples - 1;
		else
			--i;
		error = SYSCTL_OUT(req, &kcollect_ary[i], sizeof(kcollect_t));
		if (error)
			break;
		--count;
	}
	return error;
}
SYSCTL_PROC(_kern, OID_AUTO, collect_data,
	CTLFLAG_RD | CTLTYPE_STRUCT, 0, 0,
	sysctl_kcollect_data, "S,kcollect", "Dump collected statistics");

static
void
kcollect_thread_init(void)
{
	thread_t td = NULL;

	/*
	 * Autosize sample retention (10 second interval)
	 */
	if ((int)kcollect_samples < 0) {
		if (kmem_lim_size() < 1024)
			kcollect_samples = 1024;
		else
			kcollect_samples = 8192;
	}

	if (kcollect_samples) {
		kcollect_ary = kmalloc(kcollect_samples * sizeof(kcollect_t),
				       M_KCOLLECT, M_WAITOK | M_ZERO);
		lwkt_create(kcollect_thread, NULL, &td, NULL, 0, 0, "kcollect");
	}
}
SYSINIT(kcol, SI_SUB_HELPER_THREADS, SI_ORDER_ANY, kcollect_thread_init, 0);