Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/riscv/kvm/vcpu_fp.c
26424 views
1
// SPDX-License-Identifier: GPL-2.0

2
/*

3
 * Copyright (C) 2021 Western Digital Corporation or its affiliates.

4
 *

5
 * Authors:

6
 *     Atish Patra <[email protected]>

7
 *     Anup Patel <[email protected]>

8
 */

9


10
#include <linux/errno.h>

11
#include <linux/err.h>

12
#include <linux/kvm_host.h>

13
#include <linux/uaccess.h>

14
#include <asm/cpufeature.h>

15


16
#ifdef CONFIG_FPU

17
void kvm_riscv_vcpu_fp_reset(struct kvm_vcpu *vcpu)

18
{

19
	struct kvm_cpu_context *cntx = &vcpu->arch.guest_context;

20


21
	cntx->sstatus &= ~SR_FS;

22
	if (riscv_isa_extension_available(vcpu->arch.isa, f) ||

23
	    riscv_isa_extension_available(vcpu->arch.isa, d))

24
		cntx->sstatus |= SR_FS_INITIAL;

25
	else

26
		cntx->sstatus |= SR_FS_OFF;

27
}

28


29
static void kvm_riscv_vcpu_fp_clean(struct kvm_cpu_context *cntx)

30
{

31
	cntx->sstatus &= ~SR_FS;

32
	cntx->sstatus |= SR_FS_CLEAN;

33
}

34


35
void kvm_riscv_vcpu_guest_fp_save(struct kvm_cpu_context *cntx,

36
				  const unsigned long *isa)

37
{

38
	if ((cntx->sstatus & SR_FS) == SR_FS_DIRTY) {

39
		if (riscv_isa_extension_available(isa, d))

40
			__kvm_riscv_fp_d_save(cntx);

41
		else if (riscv_isa_extension_available(isa, f))

42
			__kvm_riscv_fp_f_save(cntx);

43
		kvm_riscv_vcpu_fp_clean(cntx);

44
	}

45
}

46


47
void kvm_riscv_vcpu_guest_fp_restore(struct kvm_cpu_context *cntx,

48
				     const unsigned long *isa)

49
{

50
	if ((cntx->sstatus & SR_FS) != SR_FS_OFF) {

51
		if (riscv_isa_extension_available(isa, d))

52
			__kvm_riscv_fp_d_restore(cntx);

53
		else if (riscv_isa_extension_available(isa, f))

54
			__kvm_riscv_fp_f_restore(cntx);

55
		kvm_riscv_vcpu_fp_clean(cntx);

56
	}

57
}

58


59
void kvm_riscv_vcpu_host_fp_save(struct kvm_cpu_context *cntx)

60
{

61
	/* No need to check host sstatus as it can be modified outside */

62
	if (riscv_isa_extension_available(NULL, d))

63
		__kvm_riscv_fp_d_save(cntx);

64
	else if (riscv_isa_extension_available(NULL, f))

65
		__kvm_riscv_fp_f_save(cntx);

66
}

67


68
void kvm_riscv_vcpu_host_fp_restore(struct kvm_cpu_context *cntx)

69
{

70
	if (riscv_isa_extension_available(NULL, d))

71
		__kvm_riscv_fp_d_restore(cntx);

72
	else if (riscv_isa_extension_available(NULL, f))

73
		__kvm_riscv_fp_f_restore(cntx);

74
}

75
#endif

76


77
int kvm_riscv_vcpu_get_reg_fp(struct kvm_vcpu *vcpu,

78
			      const struct kvm_one_reg *reg,

79
			      unsigned long rtype)

80
{

81
	struct kvm_cpu_context *cntx = &vcpu->arch.guest_context;

82
	unsigned long __user *uaddr =

83
			(unsigned long __user *)(unsigned long)reg->addr;

84
	unsigned long reg_num = reg->id & ~(KVM_REG_ARCH_MASK |

85
					    KVM_REG_SIZE_MASK |

86
					    rtype);

87
	void *reg_val;

88


89
	if ((rtype == KVM_REG_RISCV_FP_F) &&

90
	    riscv_isa_extension_available(vcpu->arch.isa, f)) {

91
		if (KVM_REG_SIZE(reg->id) != sizeof(u32))

92
			return -EINVAL;

93
		if (reg_num == KVM_REG_RISCV_FP_F_REG(fcsr))

94
			reg_val = &cntx->fp.f.fcsr;

95
		else if ((KVM_REG_RISCV_FP_F_REG(f[0]) <= reg_num) &&

96
			  reg_num <= KVM_REG_RISCV_FP_F_REG(f[31]))

97
			reg_val = &cntx->fp.f.f[reg_num];

98
		else

99
			return -ENOENT;

100
	} else if ((rtype == KVM_REG_RISCV_FP_D) &&

101
		   riscv_isa_extension_available(vcpu->arch.isa, d)) {

102
		if (reg_num == KVM_REG_RISCV_FP_D_REG(fcsr)) {

103
			if (KVM_REG_SIZE(reg->id) != sizeof(u32))

104
				return -EINVAL;

105
			reg_val = &cntx->fp.d.fcsr;

106
		} else if ((KVM_REG_RISCV_FP_D_REG(f[0]) <= reg_num) &&

107
			   reg_num <= KVM_REG_RISCV_FP_D_REG(f[31])) {

108
			if (KVM_REG_SIZE(reg->id) != sizeof(u64))

109
				return -EINVAL;

110
			reg_val = &cntx->fp.d.f[reg_num];

111
		} else

112
			return -ENOENT;

113
	} else

114
		return -ENOENT;

115


116
	if (copy_to_user(uaddr, reg_val, KVM_REG_SIZE(reg->id)))

117
		return -EFAULT;

118


119
	return 0;

120
}

121


122
int kvm_riscv_vcpu_set_reg_fp(struct kvm_vcpu *vcpu,

123
			      const struct kvm_one_reg *reg,

124
			      unsigned long rtype)

125
{

126
	struct kvm_cpu_context *cntx = &vcpu->arch.guest_context;

127
	unsigned long __user *uaddr =

128
			(unsigned long __user *)(unsigned long)reg->addr;

129
	unsigned long reg_num = reg->id & ~(KVM_REG_ARCH_MASK |

130
					    KVM_REG_SIZE_MASK |

131
					    rtype);

132
	void *reg_val;

133


134
	if ((rtype == KVM_REG_RISCV_FP_F) &&

135
	    riscv_isa_extension_available(vcpu->arch.isa, f)) {

136
		if (KVM_REG_SIZE(reg->id) != sizeof(u32))

137
			return -EINVAL;

138
		if (reg_num == KVM_REG_RISCV_FP_F_REG(fcsr))

139
			reg_val = &cntx->fp.f.fcsr;

140
		else if ((KVM_REG_RISCV_FP_F_REG(f[0]) <= reg_num) &&

141
			  reg_num <= KVM_REG_RISCV_FP_F_REG(f[31]))

142
			reg_val = &cntx->fp.f.f[reg_num];

143
		else

144
			return -ENOENT;

145
	} else if ((rtype == KVM_REG_RISCV_FP_D) &&

146
		   riscv_isa_extension_available(vcpu->arch.isa, d)) {

147
		if (reg_num == KVM_REG_RISCV_FP_D_REG(fcsr)) {

148
			if (KVM_REG_SIZE(reg->id) != sizeof(u32))

149
				return -EINVAL;

150
			reg_val = &cntx->fp.d.fcsr;

151
		} else if ((KVM_REG_RISCV_FP_D_REG(f[0]) <= reg_num) &&

152
			   reg_num <= KVM_REG_RISCV_FP_D_REG(f[31])) {

153
			if (KVM_REG_SIZE(reg->id) != sizeof(u64))

154
				return -EINVAL;

155
			reg_val = &cntx->fp.d.f[reg_num];

156
		} else

157
			return -ENOENT;

158
	} else

159
		return -ENOENT;

160


161
	if (copy_from_user(reg_val, uaddr, KVM_REG_SIZE(reg->id)))

162
		return -EFAULT;

163


164
	return 0;

165
}

166


167