// SPDX-License-Identifier: LGPL-2.1
/*
 * Copyright (C) 2020, VMware, Tzvetomir Stoyanov tz.stoyanov@gmail.com>
 *
 */

#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <dirent.h>
#include <ctype.h>

#include "trace-cmd.h"
#include "trace-cmd-private.h"
#include "tracefs.h"
#include "trace-tsync-local.h"

#define KVM_DEBUG_FS "/sys/kernel/debug/kvm"
#define KVM_DEBUG_OFFSET_FILE	"tsc-offset"
#define KVM_DEBUG_SCALING_FILE	"tsc-scaling-ratio"
#define KVM_DEBUG_FRACTION_FILE	"tsc-scaling-ratio-frac-bits"
#define KVM_DEBUG_VCPU_DIR	"vcpu"

/* default KVM scaling values, taken from the Linux kernel */
#define KVM_SCALING_AMD_DEFAULT		(1ULL<<32)
#define KVM_SCALING_INTEL_DEFAULT	(1ULL<<48)

#define KVM_SYNC_PKT_REQUEST	1
#define KVM_SYNC_PKT_RESPONSE	2

typedef __s64 s64;

#define KVM_ACCURACY	0
#define KVM_NAME	"kvm"

struct kvm_clock_sync {
	int vcpu_count;
	char **vcpu_offsets;
	char **vcpu_scalings;
	char **vcpu_frac;
	int marker_fd;
	struct tep_handle *tep;
	int raw_id;
	unsigned long long ts;
};

struct kvm_clock_offset_msg {
	s64	ts;
	s64	offset;
	s64	scaling;
	s64	frac;
};

static int read_ll_from_file(char *file, long long *res)
{
	char buf[32];
	int ret;
	int fd;

	if (!file)
		return -1;
	fd = open(file, O_RDONLY | O_NONBLOCK);
	if (fd < 0)
		return -1;
	ret = read(fd, buf, 32);
	close(fd);
	if (ret <= 0)
		return -1;

	*res = strtoll(buf, NULL, 0);

	return 0;
}

static bool kvm_scaling_check_vm_cpu(char *vname, char *cpu)
{
	long long scaling, frac;
	bool has_scaling = false;
	bool has_frac = false;
	char *path;
	int ret;

	if (asprintf(&path, "%s/%s/%s", vname, cpu, KVM_DEBUG_SCALING_FILE) < 0)
		return false;
	ret = read_ll_from_file(path, &scaling);
	free(path);
	if (!ret)
		has_scaling = true;

	if (asprintf(&path, "%s/%s/%s", vname, cpu, KVM_DEBUG_FRACTION_FILE) < 0)
		return false;
	ret = read_ll_from_file(path, &frac);
	free(path);
	if (!ret)
		has_frac = true;

	if (has_scaling != has_frac)
		return false;

	return true;
}

static bool kvm_scaling_check_vm(char *name)
{
	struct dirent *entry;
	char *vdir;
	DIR *dir;

	if (asprintf(&vdir, "%s/%s", KVM_DEBUG_FS, name) < 0)
		return true;

	dir = opendir(vdir);
	if (!dir) {
		free(vdir);
		return true;
	}
	while ((entry = readdir(dir))) {
		if (entry->d_type == DT_DIR && !strncmp(entry->d_name, "vcpu", 4) &&
		    !kvm_scaling_check_vm_cpu(vdir, entry->d_name))
			break;
	}

	closedir(dir);
	free(vdir);
	return entry == NULL;
}
static bool kvm_scaling_check(void)
{
	struct dirent *entry;
	DIR *dir;

	dir = opendir(KVM_DEBUG_FS);
	if (!dir)
		return true;

	while ((entry = readdir(dir))) {
		if (entry->d_type == DT_DIR && isdigit(entry->d_name[0]) &&
		    !kvm_scaling_check_vm(entry->d_name))
			break;
	}
	closedir(dir);
	return entry == NULL;
}

static bool kvm_support_check(bool guest)
{
	struct stat st;
	int ret;

	if (guest)
		return true;

	ret = stat(KVM_DEBUG_FS, &st);
	if (ret < 0)
		return false;

	if (!S_ISDIR(st.st_mode))
		return false;

	return kvm_scaling_check();
}

static int kvm_open_vcpu_dir(struct kvm_clock_sync *kvm, int cpu, char *dir_str)
{
	struct dirent *entry;
	char path[PATH_MAX];
	DIR *dir;

	dir = opendir(dir_str);
	if (!dir)
		goto error;
	while ((entry = readdir(dir))) {
		if (entry->d_type != DT_DIR) {
			if (!strcmp(entry->d_name, KVM_DEBUG_OFFSET_FILE)) {
				snprintf(path, sizeof(path), "%s/%s",
					 dir_str, entry->d_name);
				kvm->vcpu_offsets[cpu] = strdup(path);
			}
			if (!strcmp(entry->d_name, KVM_DEBUG_SCALING_FILE)) {
				snprintf(path, sizeof(path), "%s/%s",
					 dir_str, entry->d_name);
				kvm->vcpu_scalings[cpu] = strdup(path);
			}
			if (!strcmp(entry->d_name, KVM_DEBUG_FRACTION_FILE)) {
				snprintf(path, sizeof(path), "%s/%s",
					 dir_str, entry->d_name);
				kvm->vcpu_frac[cpu] = strdup(path);
			}
		}
	}
	if (!kvm->vcpu_offsets[cpu])
		goto error;
	closedir(dir);
	return 0;

error:
	if (dir)
		closedir(dir);
	free(kvm->vcpu_offsets[cpu]);
	kvm->vcpu_offsets[cpu] = NULL;
	free(kvm->vcpu_scalings[cpu]);
	kvm->vcpu_scalings[cpu] = NULL;
	free(kvm->vcpu_frac[cpu]);
	kvm->vcpu_frac[cpu] = NULL;
	return -1;
}

static int kvm_open_debug_files(struct kvm_clock_sync *kvm, int pid)
{
	char *vm_dir_str = NULL;
	struct dirent *entry;
	char *pid_str = NULL;
	char path[PATH_MAX];
	long vcpu;
	DIR *dir;
	int i;

	dir = opendir(KVM_DEBUG_FS);
	if (!dir)
		goto error;
	if (asprintf(&pid_str, "%d-", pid) <= 0)
		goto error;
	while ((entry = readdir(dir))) {
		if (!(entry->d_type == DT_DIR &&
		    !strncmp(entry->d_name, pid_str, strlen(pid_str))))
			continue;
		asprintf(&vm_dir_str, "%s/%s", KVM_DEBUG_FS, entry->d_name);
		break;
	}
	closedir(dir);
	dir = NULL;
	if (!vm_dir_str)
		goto error;
	dir = opendir(vm_dir_str);
	if (!dir)
		goto error;
	while ((entry = readdir(dir))) {
		if (!(entry->d_type == DT_DIR &&
		    !strncmp(entry->d_name, KVM_DEBUG_VCPU_DIR, strlen(KVM_DEBUG_VCPU_DIR))))
			continue;
		vcpu =  strtol(entry->d_name + strlen(KVM_DEBUG_VCPU_DIR), NULL, 10);
		if (vcpu < 0 || vcpu >= kvm->vcpu_count)
			continue;
		snprintf(path, sizeof(path), "%s/%s", vm_dir_str, entry->d_name);
		if (kvm_open_vcpu_dir(kvm, vcpu, path) < 0)
			goto error;
	}
	for (i = 0; i < kvm->vcpu_count; i++) {
		if (!kvm->vcpu_offsets[i])
			goto error;
	}
	closedir(dir);
	free(pid_str);
	free(vm_dir_str);
	return 0;
error:
	free(pid_str);
	free(vm_dir_str);
	if (dir)
		closedir(dir);
	return -1;
}

static int kvm_clock_sync_init_host(struct tracecmd_time_sync *tsync,
				    struct kvm_clock_sync *kvm)
{
	kvm->vcpu_count = tsync->vcpu_count;
	kvm->vcpu_offsets = calloc(kvm->vcpu_count, sizeof(char *));
	kvm->vcpu_scalings = calloc(kvm->vcpu_count, sizeof(char *));
	kvm->vcpu_frac = calloc(kvm->vcpu_count, sizeof(char *));
	if (!kvm->vcpu_offsets || !kvm->vcpu_scalings || !kvm->vcpu_frac)
		goto error;
	if (kvm_open_debug_files(kvm, tsync->guest_pid) < 0)
		goto error;
	return 0;

error:
	free(kvm->vcpu_offsets);
	free(kvm->vcpu_scalings);
	free(kvm->vcpu_frac);
	return -1;
}

static int kvm_clock_sync_init_guest(struct tracecmd_time_sync *tsync,
				     struct kvm_clock_sync *kvm)
{
	const char *systems[] = {"ftrace", NULL};
	struct clock_sync_context *clock_context;
	struct tep_event *raw;
	char *path;

	clock_context = (struct clock_sync_context *)tsync->context;
	path = tracefs_instance_get_dir(clock_context->instance);
	if (!path)
		goto error;
	kvm->tep = tracefs_local_events_system(path, systems);
	tracefs_put_tracing_file(path);
	if (!kvm->tep)
		goto error;
	raw = tep_find_event_by_name(kvm->tep, "ftrace", "raw_data");
	if (!raw)
		goto error;

	kvm->raw_id = raw->id;
	tep_set_file_bigendian(kvm->tep, tracecmd_host_bigendian());
	tep_set_local_bigendian(kvm->tep, tracecmd_host_bigendian());

	path = tracefs_instance_get_file(clock_context->instance, "trace_marker_raw");
	if (!path)
		goto error;
	kvm->marker_fd = open(path, O_WRONLY);
	tracefs_put_tracing_file(path);

	return 0;

error:
	if (kvm->tep)
		tep_free(kvm->tep);
	if (kvm->marker_fd >= 0)
		close(kvm->marker_fd);

	return -1;
}

static int kvm_clock_sync_init(struct tracecmd_time_sync *tsync)
{
	struct clock_sync_context *clock_context;
	struct kvm_clock_sync *kvm;
	int ret;

	if (!tsync || !tsync->context)
		return -1;
	clock_context = (struct clock_sync_context *)tsync->context;

	if (!kvm_support_check(clock_context->is_guest))
		return -1;
	kvm = calloc(1, sizeof(struct kvm_clock_sync));
	if (!kvm)
		return -1;
	kvm->marker_fd = -1;
	if (clock_context->is_guest)
		ret = kvm_clock_sync_init_guest(tsync, kvm);
	else
		ret = kvm_clock_sync_init_host(tsync, kvm);
	if (ret < 0)
		goto error;

	clock_context->proto_data = kvm;
	return 0;

error:
	free(kvm);
	return -1;
}

static int kvm_clock_sync_free(struct tracecmd_time_sync *tsync)
{
	struct clock_sync_context *clock_context;
	struct kvm_clock_sync *kvm = NULL;
	int i;

	clock_context = (struct clock_sync_context *)tsync->context;
	if (clock_context)
		kvm = (struct kvm_clock_sync *)clock_context->proto_data;
	if (kvm) {
		for (i = 0; i < kvm->vcpu_count; i++) {
			free(kvm->vcpu_offsets[i]);
			kvm->vcpu_offsets[i] = NULL;
			free(kvm->vcpu_scalings[i]);
			kvm->vcpu_scalings[i] = NULL;
			free(kvm->vcpu_frac[i]);
			kvm->vcpu_frac[i] = NULL;
		}
		if (kvm->tep)
			tep_free(kvm->tep);
		if (kvm->marker_fd >= 0)
			close(kvm->marker_fd);
		free(kvm);
	}
	return -1;
}

static int kvm_clock_host(struct tracecmd_time_sync *tsync,
			  long long *offset, long long *scaling, long long *frac,
			  long long *timestamp, unsigned int cpu)
{
	char sync_proto[TRACECMD_TSYNC_PNAME_LENGTH];
	struct clock_sync_context *clock_context;
	struct kvm_clock_offset_msg packet;
	struct kvm_clock_sync *kvm = NULL;
	long long kvm_scaling = 1;
	unsigned int sync_msg;
	long long kvm_offset;
	long long kvm_frac = 0;
	unsigned int size;
	char *msg;
	int ret;

	clock_context = (struct clock_sync_context *)tsync->context;
	if (clock_context)
		kvm = (struct kvm_clock_sync *)clock_context->proto_data;
	if (!kvm || !kvm->vcpu_offsets || !kvm->vcpu_offsets[0])
		return -1;
	if (cpu >= kvm->vcpu_count)
		return -1;
	ret = read_ll_from_file(kvm->vcpu_offsets[cpu], &kvm_offset);
	if (ret < 0)
		return -1;

	if (kvm->vcpu_scalings && kvm->vcpu_scalings[cpu]) {
		read_ll_from_file(kvm->vcpu_scalings[cpu], &kvm_scaling);
		if (kvm_scaling == KVM_SCALING_AMD_DEFAULT ||
		    kvm_scaling == KVM_SCALING_INTEL_DEFAULT)
			kvm_scaling = 1;
	}

	if (kvm->vcpu_frac && kvm->vcpu_frac[cpu] && kvm_scaling != 1)
		ret = read_ll_from_file(kvm->vcpu_frac[cpu], &kvm_frac);
	msg = (char *)&packet;
	size = sizeof(packet);
	ret = tracecmd_msg_recv_time_sync(tsync->msg_handle,
					  sync_proto, &sync_msg,
					  &size, &msg);
	if (ret || strncmp(sync_proto, KVM_NAME, TRACECMD_TSYNC_PNAME_LENGTH) ||
	    sync_msg != KVM_SYNC_PKT_REQUEST)
		return -1;

	packet.offset = -kvm_offset;
	packet.scaling = kvm_scaling;
	packet.frac = kvm_frac;
	ret = tracecmd_msg_send_time_sync(tsync->msg_handle, KVM_NAME,
					  KVM_SYNC_PKT_RESPONSE, sizeof(packet),
					  (char *)&packet);
	if (ret)
		return -1;

	*scaling = packet.scaling;
	*offset = packet.offset;
	*frac = kvm_frac;
	*timestamp = packet.ts;

	return 0;
}

#define KVM_EVENT_MARKER	"kvm sync event"
static int kvm_marker_find(struct tep_event *event, struct tep_record *record,
			   int cpu, void *context)
{
	struct kvm_clock_sync *kvm = (struct kvm_clock_sync *)context;
	struct tep_format_field *field;
	struct tep_format_field *id;
	char *marker;

	/* Make sure this is our event */
	if (event->id != kvm->raw_id)
		return 0;
	id = tep_find_field(event, "id");
	field = tep_find_field(event, "buf");
	if (field && id &&
	    record->size >= (id->offset + strlen(KVM_EVENT_MARKER) + 1)) {
		marker = (char *)(record->data + id->offset);
		if (!strcmp(marker, KVM_EVENT_MARKER)) {
			kvm->ts = record->ts;
			return 1;
		}
	}

	return 0;
}

static int kvm_clock_guest(struct tracecmd_time_sync *tsync,
			   long long *offset,
			   long long *scaling,
			   long long *frac,
			   long long *timestamp)
{
	char sync_proto[TRACECMD_TSYNC_PNAME_LENGTH];
	struct clock_sync_context *clock_context;
	struct kvm_clock_offset_msg packet;
	struct kvm_clock_sync *kvm = NULL;
	unsigned int sync_msg;
	unsigned int size;
	char *msg;
	int ret;

	clock_context = (struct clock_sync_context *)tsync->context;
	if (clock_context)
		kvm = (struct kvm_clock_sync *)clock_context->proto_data;
	if (!kvm)
		return -1;
	kvm->ts = 0;
	memset(&packet, 0, sizeof(packet));
	tracefs_instance_file_write(clock_context->instance, "trace", "\0");
	write(kvm->marker_fd, KVM_EVENT_MARKER, strlen(KVM_EVENT_MARKER) + 1);
	kvm->ts = 0;
	tracefs_iterate_raw_events(kvm->tep, clock_context->instance,
				   NULL, 0, kvm_marker_find, kvm);
	packet.ts = kvm->ts;
	ret = tracecmd_msg_send_time_sync(tsync->msg_handle, KVM_NAME,
					  KVM_SYNC_PKT_REQUEST, sizeof(packet),
					  (char *)&packet);
	if (ret)
		return -1;
	msg = (char *)&packet;
	size = sizeof(packet);
	ret = tracecmd_msg_recv_time_sync(tsync->msg_handle,
					  sync_proto, &sync_msg,
					  &size, &msg);
	if (ret || strncmp(sync_proto, KVM_NAME, TRACECMD_TSYNC_PNAME_LENGTH) ||
	    sync_msg != KVM_SYNC_PKT_RESPONSE)
		return -1;

	*scaling = packet.scaling;
	*offset = packet.offset;
	*frac = packet.frac;
	*timestamp = packet.ts;
	return 0;
}

static int kvm_clock_sync_calc(struct tracecmd_time_sync *tsync,
			       long long *offset, long long *scaling, long long *frac,
			       long long *timestamp, unsigned int cpu)
{
	struct clock_sync_context *clock_context;
	int ret;

	if (!tsync || !tsync->context)
		return -1;

	clock_context = (struct clock_sync_context *)tsync->context;

	if (clock_context->is_guest)
		ret = kvm_clock_guest(tsync, offset, scaling, frac, timestamp);
	else
		ret = kvm_clock_host(tsync, offset, scaling, frac, timestamp, cpu);
	return ret;
}

int kvm_clock_sync_register(void)
{
	int role = TRACECMD_TIME_SYNC_ROLE_GUEST;
	int clock = 0;

	if (kvm_support_check(false)) {
		role |= TRACECMD_TIME_SYNC_ROLE_HOST;
		clock = TRACECMD_CLOCK_X86_TSC;
	}
	return tracecmd_tsync_proto_register(KVM_NAME, KVM_ACCURACY,
					     role, clock, 0,
					     kvm_clock_sync_init,
					     kvm_clock_sync_free,
					     kvm_clock_sync_calc);
}

int kvm_clock_sync_unregister(void)
{
	return tracecmd_tsync_proto_unregister(KVM_NAME);
}