// SPDX-License-Identifier: GPL-2.0-or-later

/* PASST - Plug A Simple Socket Transport
 *  for qemu/UNIX domain socket mode
 *
 * PASTA - Pack A Subtle Tap Abstraction
 *  for network namespace/tap device mode
 *
 * migrate.c - Migration sections, layout, and routines
 *
 * Copyright (c) 2025 Red Hat GmbH
 * Author: Stefano Brivio <sbrivio@redhat.com>
 */

#include <errno.h>
#include <sys/uio.h>

#include "util.h"
#include "ip.h"
#include "passt.h"
#include "inany.h"
#include "flow.h"
#include "flow_table.h"

#include "migrate.h"
#include "repair.h"

/* Magic identifier for migration data */
#define MIGRATE_MAGIC		0xB1BB1D1B0BB1D1B0

/**
 * struct migrate_seen_addrs_v2 - Migratable observed guest addresses
 * @addr6:	Observed guest IPv6 address
 * @addr6_ll:	Observed guest IPv6 link-local address
 * @addr4:	Observed guest IPv4 address
 * @mac:	Observed guest MAC address
 */
struct migrate_seen_addrs_v2 {
	struct in6_addr addr6;
	struct in6_addr addr6_ll;
	struct in_addr addr4;
	unsigned char mac[ETH_ALEN];
} __attribute__((packed));

/**
 * struct migrate_seen_addrs_v3 - Migratable observed guest addresses
 * @addr_count:	Number of address entries
 * @addrs:	Array of observed address entries
 * @mac:	Observed guest MAC address
 */
struct migrate_seen_addrs_v3 {
	uint8_t addr_count;
	struct inany_addr_entry addrs[INANY_MAX_ADDRS];
	unsigned char mac[ETH_ALEN];
} __packed;

/**
 * seen_addrs_source_v2() - Send observed addresses from source
 * @c:		Execution context
 * @stage:	Migration stage, unused
 * @fd:		File descriptor for state transfer
 *
 * Return: 0 on success, positive error code on failure
 */
/* cppcheck-suppress [constParameterCallback, unmatchedSuppression] */
static int seen_addrs_source_v2(struct ctx *c,
				const struct migrate_stage *stage, int fd)
{
	struct migrate_seen_addrs_v2 addrs = { 0 };
	const struct inany_addr_entry *e;

	(void)stage;

	/* Find first observed IPv4 address */
	for_each_addr(c, e, AF_INET) {
		if (e->flags & INANY_ADDR_OBSERVED) {
			addrs.addr4 = *inany_v4(&e->addr);
			break;
		}
	}

	/* Find first observed IPv6 addresses (global and link-local) */
	for_each_addr(c, e, AF_INET6) {
		struct in6_addr tmp;

		if (!(e->flags & INANY_ADDR_OBSERVED))
			continue;
		if (e->flags & INANY_ADDR_LINKLOCAL) {
			tmp = addrs.addr6_ll;
			if (IN6_IS_ADDR_UNSPECIFIED(&tmp))
				addrs.addr6_ll = e->addr.a6;
		} else {
			tmp = addrs.addr6;
			if (IN6_IS_ADDR_UNSPECIFIED(&tmp))
				addrs.addr6 = e->addr.a6;
		}
	}

	memcpy(addrs.mac, c->guest_mac, sizeof(addrs.mac));

	if (write_all_buf(fd, &addrs, sizeof(addrs)))
		return errno;

	return 0;
}

/**
 * migrate_observed_addr4() - Add observed IPv4 address to address array
 * @c:		Execution context
 * @addr:	IPv4 address to add
 */
static void migrate_observed_addr4(struct ctx *c, const struct in_addr *addr)
{
	struct inany_addr_entry *e;

	if (IN4_IS_ADDR_UNSPECIFIED(addr))
		return;

	for_each_addr(c, e, AF_INET) {
		if (IN4_ARE_ADDR_EQUAL(addr, inany_v4(&e->addr))) {
			e->flags |= INANY_ADDR_OBSERVED;
			return;
		}
	}

	if (c->addr_count < INANY_MAX_ADDRS) {
		c->addrs[c->addr_count].addr = inany_from_v4(*addr);
		c->addrs[c->addr_count].prefix_len = 0;
		c->addrs[c->addr_count].flags = INANY_ADDR_OBSERVED;
		c->addr_count++;
	}
}

/**
 * migrate_observed_addr6() - Add observed IPv6 address to address array
 * @c:		Execution context
 * @addr:	IPv6 address to add
 */
static void migrate_observed_addr6(struct ctx *c, const struct in6_addr *addr)
{
	uint8_t flags = INANY_ADDR_OBSERVED;
	struct inany_addr_entry *e;

	if (IN6_IS_ADDR_UNSPECIFIED(addr))
		return;

	if (IN6_IS_ADDR_LINKLOCAL(addr))
		flags |= INANY_ADDR_LINKLOCAL;

	for_each_addr(c, e, AF_INET6) {
		if (IN6_ARE_ADDR_EQUAL(addr, &e->addr.a6)) {
			e->flags |= flags;
			return;
		}
	}

	if (c->addr_count < INANY_MAX_ADDRS) {
		c->addrs[c->addr_count].addr.a6 = *addr;
		c->addrs[c->addr_count].prefix_len = 0;
		c->addrs[c->addr_count].flags = flags;
		c->addr_count++;
	}
}

/**
 * seen_addrs_target_v2() - Receive observed addresses on target
 * @c:		Execution context
 * @stage:	Migration stage, unused
 * @fd:		File descriptor for state transfer
 *
 * Return: 0 on success, positive error code on failure
 */
static int seen_addrs_target_v2(struct ctx *c,
				const struct migrate_stage *stage, int fd)
{
	struct migrate_seen_addrs_v2 addrs;
	struct in6_addr addr6, addr6_ll;
	struct in_addr addr4;

	(void)stage;

	if (read_all_buf(fd, &addrs, sizeof(addrs)))
		return errno;

	/* Copy from packed struct to avoid alignment issues */
	addr4 = addrs.addr4;
	addr6 = addrs.addr6;
	addr6_ll = addrs.addr6_ll;

	migrate_observed_addr4(c, &addr4);
	migrate_observed_addr6(c, &addr6);
	migrate_observed_addr6(c, &addr6_ll);

	memcpy(c->guest_mac, addrs.mac, sizeof(c->guest_mac));

	return 0;
}

/**
 * seen_addrs_source_v3() - Send observed addresses from source
 * @c:		Execution context
 * @stage:	Migration stage, unused
 * @fd:		File descriptor for state transfer
 *
 * Return: 0 on success, positive error code on failure
 */
/* cppcheck-suppress [constParameterCallback, unmatchedSuppression] */
static int seen_addrs_source_v3(struct ctx *c,
				const struct migrate_stage *stage, int fd)
{
	struct migrate_seen_addrs_v3 addrs = { .addr_count = 0 };
	const struct inany_addr_entry *e;

	(void)stage;

	/* Copy only observed address entries */
	for_each_addr(c, e, 0) {
		if ((e->flags & INANY_ADDR_OBSERVED) &&
		    addrs.addr_count < INANY_MAX_ADDRS)
			addrs.addrs[addrs.addr_count++] = *e;
	}

	memcpy(addrs.mac, c->guest_mac, sizeof(addrs.mac));

	if (write_all_buf(fd, &addrs, sizeof(addrs)))
		return errno;

	return 0;
}

/**
 * migrate_observed_addr() - Add observed address to address array
 * @c:		Execution context
 * @addr:	Address entry to add
 */
static void migrate_observed_addr(struct ctx *c,
				  const struct inany_addr_entry *addr)
{
	struct inany_addr_entry *e;

	if (inany_is_unspecified(&addr->addr))
		return;

	/* Check if address already exists, just mark it observed */
	for_each_addr(c, e, 0) {
		if (inany_equals(&e->addr, &addr->addr)) {
			e->flags |= INANY_ADDR_OBSERVED;
			return;
		}
	}

	/* Add new entry if there's room */
	if (c->addr_count < INANY_MAX_ADDRS)
		c->addrs[c->addr_count++] = *addr;
}

/**
 * seen_addrs_target_v3() - Receive observed addresses on target
 * @c:		Execution context
 * @stage:	Migration stage, unused
 * @fd:		File descriptor for state transfer
 *
 * Return: 0 on success, positive error code on failure
 */
static int seen_addrs_target_v3(struct ctx *c,
				const struct migrate_stage *stage, int fd)
{
	struct migrate_seen_addrs_v3 addrs;
	uint8_t i;

	(void)stage;

	if (read_all_buf(fd, &addrs, sizeof(addrs)))
		return errno;

	/* Merge observed addresses into existing array */
	for (i = 0; i < addrs.addr_count && i < INANY_MAX_ADDRS; i++) {
		struct inany_addr_entry e = addrs.addrs[i];

		migrate_observed_addr(c, &e);
	}

	memcpy(c->guest_mac, addrs.mac, sizeof(c->guest_mac));

	return 0;
}

/* Stages for version 2 */
static const struct migrate_stage stages_v2[] = {
	{
		.name = "observed addresses",
		.source = seen_addrs_source_v2,
		.target = seen_addrs_target_v2,
	},
	{
		.name = "prepare flows",
		.source = flow_migrate_source_pre,
		.target = NULL,
	},
	{
		.name = "transfer flows",
		.source = flow_migrate_source,
		.target = flow_migrate_target,
	},
	{ 0 },
};

/* Stages for version 3 (multiple observed IPv4 addresses) */
static const struct migrate_stage stages_v3[] = {
	{
		.name = "observed addresses",
		.source = seen_addrs_source_v3,
		.target = seen_addrs_target_v3,
	},
	{
		.name = "prepare flows",
		.source = flow_migrate_source_pre,
		.target = NULL,
	},
	{
		.name = "transfer flows",
		.source = flow_migrate_source,
		.target = flow_migrate_target,
	},
	{ 0 },
};

/* Supported encoding versions, from latest (most preferred) to oldest */
static const struct migrate_version versions[] = {
	{ 3,	stages_v3, },
	{ 2,	stages_v2, },
	/* v1 was released, but not widely used.  It had bad endianness for the
	 * MSS and omitted timestamps, which meant it usually wouldn't work.
	 * Therefore we don't attempt to support compatibility with it.
	 */
	{ 0 },
};

/* Current encoding version */
#define CURRENT_VERSION		(&versions[0])

/**
 * migrate_source() - Migration as source, send state to hypervisor
 * @c:		Execution context
 * @fd:		File descriptor for state transfer
 *
 * Return: 0 on success, positive error code on failure
 */
static int migrate_source(struct ctx *c, int fd)
{
	const struct migrate_version *v = CURRENT_VERSION;
	const struct migrate_header header = {
		.magic		= htonll_constant(MIGRATE_MAGIC),
		.version	= htonl(v->id),
		.compat_version	= htonl(v->id),
	};
	const struct migrate_stage *s;
	int ret;

	if (write_all_buf(fd, &header, sizeof(header))) {
		ret = errno;
		err("Can't send migration header: %s, abort", strerror_(ret));
		return ret;
	}

	for (s = v->s; s->name; s++) {
		if (!s->source)
			continue;

		debug("Source side migration stage: %s", s->name);

		if ((ret = s->source(c, s, fd))) {
			err("Source migration stage: %s: %s, abort", s->name,
			    strerror_(ret));
			return ret;
		}
	}

	return 0;
}

/**
 * migrate_target_read_header() - Read header in target
 * @fd:		Descriptor for state transfer
 *
 * Return: version structure on success, NULL on failure with errno set
 */
static const struct migrate_version *migrate_target_read_header(int fd)
{
	const struct migrate_version *v;
	struct migrate_header h;
	uint32_t id, compat_id;

	if (read_all_buf(fd, &h, sizeof(h)))
		return NULL;

	id = ntohl(h.version);
	compat_id = ntohl(h.compat_version);

	debug("Source magic: 0x%016" PRIx64 ", version: %u, compat: %u",
	      ntohll(h.magic), id, compat_id);

	if (ntohll(h.magic) != MIGRATE_MAGIC || !id || !compat_id) {
		err("Invalid incoming device state");
		errno = EINVAL;
		return NULL;
	}

	for (v = versions; v->id; v++)
		if (v->id <= id && v->id >= compat_id)
			return v;

	errno = ENOTSUP;
	err("Unsupported device state version: %u", id);
	return NULL;
}

/**
 * migrate_target() - Migration as target, receive state from hypervisor
 * @c:		Execution context
 * @fd:		File descriptor for state transfer
 *
 * Return: 0 on success, positive error code on failure
 */
static int migrate_target(struct ctx *c, int fd)
{
	const struct migrate_version *v;
	const struct migrate_stage *s;
	int ret;

	if (!(v = migrate_target_read_header(fd)))
		return errno;

	for (s = v->s; s->name; s++) {
		if (!s->target)
			continue;

		debug("Target side migration stage: %s", s->name);

		if ((ret = s->target(c, s, fd))) {
			err("Target migration stage: %s: %s, abort", s->name,
			    strerror_(ret));
			return ret;
		}
	}

	return 0;
}

/**
 * migrate_init() - Set up things necessary for migration
 * @c:		Execution context
 */
void migrate_init(struct ctx *c)
{
	c->device_state_result = -1;
}

/**
 * migrate_close() - Close migration channel and connection to passt-repair
 * @c:		Execution context
 */
void migrate_close(struct ctx *c)
{
	if (c->device_state_fd != -1) {
		debug("Closing migration channel, fd: %d", c->device_state_fd);
		close(c->device_state_fd);
		c->device_state_fd = -1;
		c->device_state_result = -1;
	}

	repair_close(c);
}

/**
 * migrate_request() - Request a migration of device state
 * @c:		Execution context
 * @fd:		fd to transfer state
 * @target:	Are we the target of the migration?
 */
void migrate_request(struct ctx *c, int fd, bool target)
{
	debug("Migration requested, fd: %d (was %d)", fd, c->device_state_fd);

	if (c->device_state_fd != -1)
		migrate_close(c);

	c->device_state_fd = fd;
	c->migrate_target = target;
}

/**
 * migrate_handler() - Send/receive passt internal state to/from hypervisor
 * @c:		Execution context
 */
void migrate_handler(struct ctx *c)
{
	int rc;

	if (c->device_state_fd < 0)
		return;

	debug("Handling migration request from fd: %d, target: %d",
	      c->device_state_fd, c->migrate_target);

	if (c->migrate_target)
		rc = migrate_target(c, c->device_state_fd);
	else
		rc = migrate_source(c, c->device_state_fd);

	migrate_close(c);

	c->device_state_result = rc;
}