/* Copyright (c) 2015 Google Inc
 * Davide Libenzi <dlibenzi@google.com>
 * See LICENSE for details.
 *
 * Part of this code coming from a Linux kernel file:
 *
 * linux/arch/x86/include/asm/uaccess.h
 *
 * Which, even though missing specific copyright, it is supposed to be
 * ruled by the overall Linux copyright.
 */

#pragma once

#include <ros/errno.h>
#include <compiler.h>
#include <stdint.h>
#include <umem.h>
#include <arch/fixup.h>

#define __m(x) *(x)

struct extable_ip_fixup {
	uint64_t insn;
	uint64_t fixup;
};

#define __read_msr_asm(eax, edx, addr, err, errret)			\
	asm volatile(ASM_STAC "\n"					\
	             "1:rdmsr\n"					\
	             "	mfence\n"					\
	             "2: " ASM_CLAC "\n"				\
	             ".section .fixup,\"ax\"\n"				\
	             "3:mov %4,%0\n"					\
	             "	jmp 2b\n"					\
	             ".previous\n"					\
	             _ASM_EXTABLE(1b, 3b)				\
	             : "=r" (err), "=d" (edx), "=a" (eax)		\
	             : "c" (addr), "i" (errret), "0" (err))

#define __write_msr_asm(val, addr, err, errret)				\
	asm volatile(ASM_STAC "\n"					\
	             "1:wrmsr\n"					\
	             "2: " ASM_CLAC "\n"				\
	             ".section .fixup,\"ax\"\n"				\
	             "3:mov %4,%0\n"					\
	             "	jmp 2b\n"					\
	             ".previous\n"					\
	             _ASM_EXTABLE(1b, 3b)				\
	             : "=r" (err)					\
	             : "d" ((uint32_t) (val >> 32)),			\
	               "a" ((uint32_t) (val & 0xffffffff)), "c" (addr),	\
	               "i" (errret), "0" (err))

#define __put_user_asm(x, addr, err, itype, rtype, ltype, errret)	\
	asm volatile(ASM_STAC "\n"					\
	             "1:mov"itype" %"rtype"1,%2\n"			\
	             "2: " ASM_CLAC "\n"				\
	             ".section .fixup,\"ax\"\n"				\
	             "3:mov %3,%0\n"					\
	             "	jmp 2b\n"					\
	             ".previous\n"					\
	             _ASM_EXTABLE(1b, 3b)				\
	             : "=r"(err)					\
	             : ltype(x), "m" (__m(addr)), "i" (errret), "0" (err))

#define __get_user_asm(x, addr, err, itype, rtype, ltype, errret)	\
	asm volatile(ASM_STAC "\n"					\
	             "1:mov"itype" %2,%"rtype"1\n"			\
	             "2: " ASM_CLAC "\n"				\
	             ".section .fixup,\"ax\"\n"				\
	             "3:mov %3,%0\n"					\
	             "	xor"itype" %"rtype"1,%"rtype"1\n"		\
	             "	jmp 2b\n"					\
	             ".previous\n"					\
	             _ASM_EXTABLE(1b, 3b)				\
	             : "=r" (err), ltype(x)				\
	             : "m" (__m(addr)), "i" (errret), "0" (err))

#define __user_memcpy(dst, src, count, err, errret)			\
	asm volatile(ASM_STAC "\n"					\
	             " 	cld\n"						\
	             "1:rep movsb\n"					\
	             "2: " ASM_CLAC "\n"				\
	             ".section .fixup,\"ax\"\n"				\
	             "3:mov %4,%0\n"					\
	             "	jmp 2b\n"					\
	             ".previous\n"					\
	             _ASM_EXTABLE(1b, 3b)				\
	             : "=r"(err), "+D" (dst), "+S" (src), "+c" (count)	\
	             : "i" (errret), "0" (err)				\
	             : "memory")

static inline int __put_user(void *dst, const void *src, unsigned int count)
{
	int err = 0;

	switch (count) {
	case 1:
		__put_user_asm(*(const uint8_t *) src, (uint8_t *) dst, err,
			       "b", "b", "iq", -EFAULT);
		break;
	case 2:
		__put_user_asm(*(const uint16_t *) src, (uint16_t *) dst, err,
			       "w", "w", "ir", -EFAULT);
		break;
	case 4:
		__put_user_asm(*(const uint32_t *) src, (uint32_t *) dst, err,
			       "l", "k", "ir", -EFAULT);
		break;
	case 8:
		__put_user_asm(*(const uint64_t *) src, (uint64_t *) dst, err,
			       "q", "", "er", -EFAULT);
		break;
	default:
		__user_memcpy(dst, src, count, err, -EFAULT);
	}

	return err;
}

static inline int copy_to_user(void *dst, const void *src, unsigned int count)
{
	int err = 0;

	if (unlikely(!is_user_rwaddr(dst, count))) {
		err = -EFAULT;
	} else if (!__builtin_constant_p(count)) {
		__user_memcpy(dst, src, count, err, -EFAULT);
	} else {
		err = __put_user(dst, src, count);
	}

	return err;
}

static inline int __get_user(void *dst, const void *src, unsigned int count)
{
	int err = 0;

	switch (count) {
	case 1:
		__get_user_asm(*(uint8_t *) dst, (const uint8_t *) src, err,
			       "b", "b", "=q", -EFAULT);
		break;
	case 2:
		__get_user_asm(*(uint16_t *) dst, (const uint16_t *) src, err,
			       "w", "w", "=r", -EFAULT);
		break;
	case 4:
		__get_user_asm(*(uint32_t *) dst, (const uint32_t *) src, err,
			       "l", "k", "=r", -EFAULT);
		break;
	case 8:
		__get_user_asm(*(uint64_t *) dst, (const uint64_t *) src, err,
			       "q", "", "=r", -EFAULT);
		break;
	default:
		__user_memcpy(dst, src, count, err, -EFAULT);
	}

	return err;
}

static inline int copy_from_user(void *dst, const void *src,
                                 unsigned int count)
{
	int err = 0;

	if (unlikely(!is_user_raddr((void *) src, count))) {
		err = -EFAULT;
	} else if (!__builtin_constant_p(count)) {
		__user_memcpy(dst, src, count, err, -EFAULT);
	} else {
		err = __get_user(dst, src, count);
	}

	return err;
}

static inline int read_msr_safe(uint32_t addr, uint64_t *value)
{
	int err = 0;
	uint32_t edx, eax;

	__read_msr_asm(eax, edx, addr, err, -EFAULT);
	if (likely(err == 0))
		*value = ((uint64_t) edx << 32) | eax;

	return err;
}

static inline int write_msr_safe(uint32_t addr, uint64_t value)
{
	int err = 0;

	__write_msr_asm(value, addr, err, -EFAULT);

	return err;
}

static inline uintptr_t ex_insn_addr(const struct extable_ip_fixup *x)
{
	return (uintptr_t) &x->insn + x->insn;
}

static inline uintptr_t ex_fixup_addr(const struct extable_ip_fixup *x)
{
	return (uintptr_t) &x->fixup + x->fixup;
}