summaryrefslogtreecommitdiffstats
path: root/arch/x86/entry/entry_fred.c
blob: ac120cbdaaf2b4c474954c9a9f148222a370a72a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
/* SPDX-License-Identifier: GPL-2.0 */
/*
 * The FRED specific kernel/user entry functions which are invoked from
 * assembly code and dispatch to the associated handlers.
 */
#include <linux/kernel.h>
#include <linux/kdebug.h>
#include <linux/nospec.h>

#include <asm/desc.h>
#include <asm/fred.h>
#include <asm/idtentry.h>
#include <asm/syscall.h>
#include <asm/trapnr.h>
#include <asm/traps.h>

/* FRED EVENT_TYPE_OTHER vector numbers */
#define FRED_SYSCALL			1
#define FRED_SYSENTER			2

static noinstr void fred_bad_type(struct pt_regs *regs, unsigned long error_code)
{
	irqentry_state_t irq_state = irqentry_nmi_enter(regs);

	instrumentation_begin();

	/* Panic on events from a high stack level */
	if (regs->fred_cs.sl > 0) {
		pr_emerg("PANIC: invalid or fatal FRED event; event type %u "
			 "vector %u error 0x%lx aux 0x%lx at %04x:%016lx\n",
			 regs->fred_ss.type, regs->fred_ss.vector, regs->orig_ax,
			 fred_event_data(regs), regs->cs, regs->ip);
		die("invalid or fatal FRED event", regs, regs->orig_ax);
		panic("invalid or fatal FRED event");
	} else {
		unsigned long flags = oops_begin();
		int sig = SIGKILL;

		pr_alert("BUG: invalid or fatal FRED event; event type %u "
			 "vector %u error 0x%lx aux 0x%lx at %04x:%016lx\n",
			 regs->fred_ss.type, regs->fred_ss.vector, regs->orig_ax,
			 fred_event_data(regs), regs->cs, regs->ip);

		if (__die("Invalid or fatal FRED event", regs, regs->orig_ax))
			sig = 0;

		oops_end(flags, regs, sig);
	}

	instrumentation_end();
	irqentry_nmi_exit(regs, irq_state);
}

static noinstr void fred_intx(struct pt_regs *regs)
{
	switch (regs->fred_ss.vector) {
	/* Opcode 0xcd, 0x3, NOT INT3 (opcode 0xcc) */
	case X86_TRAP_BP:
		return exc_int3(regs);

	/* Opcode 0xcd, 0x4, NOT INTO (opcode 0xce) */
	case X86_TRAP_OF:
		return exc_overflow(regs);

#ifdef CONFIG_IA32_EMULATION
	/* INT80 */
	case IA32_SYSCALL_VECTOR:
		if (ia32_enabled())
			return int80_emulation(regs);
		fallthrough;
#endif

	default:
		return exc_general_protection(regs, 0);
	}
}

static __always_inline void fred_other(struct pt_regs *regs)
{
	/* The compiler can fold these conditions into a single test */
	if (likely(regs->fred_ss.vector == FRED_SYSCALL && regs->fred_ss.lm)) {
		regs->orig_ax = regs->ax;
		regs->ax = -ENOSYS;
		do_syscall_64(regs, regs->orig_ax);
		return;
	} else if (ia32_enabled() &&
		   likely(regs->fred_ss.vector == FRED_SYSENTER && !regs->fred_ss.lm)) {
		regs->orig_ax = regs->ax;
		regs->ax = -ENOSYS;
		do_fast_syscall_32(regs);
		return;
	} else {
		exc_invalid_op(regs);
		return;
	}
}

#define SYSVEC(_vector, _function) [_vector - FIRST_SYSTEM_VECTOR] = fred_sysvec_##_function

static idtentry_t sysvec_table[NR_SYSTEM_VECTORS] __ro_after_init = {
	SYSVEC(ERROR_APIC_VECTOR,		error_interrupt),
	SYSVEC(SPURIOUS_APIC_VECTOR,		spurious_apic_interrupt),
	SYSVEC(LOCAL_TIMER_VECTOR,		apic_timer_interrupt),
	SYSVEC(X86_PLATFORM_IPI_VECTOR,		x86_platform_ipi),

	SYSVEC(RESCHEDULE_VECTOR,		reschedule_ipi),
	SYSVEC(CALL_FUNCTION_SINGLE_VECTOR,	call_function_single),
	SYSVEC(CALL_FUNCTION_VECTOR,		call_function),
	SYSVEC(REBOOT_VECTOR,			reboot),

	SYSVEC(THRESHOLD_APIC_VECTOR,		threshold),
	SYSVEC(DEFERRED_ERROR_VECTOR,		deferred_error),
	SYSVEC(THERMAL_APIC_VECTOR,		thermal),

	SYSVEC(IRQ_WORK_VECTOR,			irq_work),

	SYSVEC(POSTED_INTR_VECTOR,		kvm_posted_intr_ipi),
	SYSVEC(POSTED_INTR_WAKEUP_VECTOR,	kvm_posted_intr_wakeup_ipi),
	SYSVEC(POSTED_INTR_NESTED_VECTOR,	kvm_posted_intr_nested_ipi),
};

static bool fred_setup_done __initdata;

void __init fred_install_sysvec(unsigned int sysvec, idtentry_t handler)
{
	if (WARN_ON_ONCE(sysvec < FIRST_SYSTEM_VECTOR))
		return;

	if (WARN_ON_ONCE(fred_setup_done))
		return;

	if (!WARN_ON_ONCE(sysvec_table[sysvec - FIRST_SYSTEM_VECTOR]))
		 sysvec_table[sysvec - FIRST_SYSTEM_VECTOR] = handler;
}

static noinstr void fred_handle_spurious_interrupt(struct pt_regs *regs)
{
	spurious_interrupt(regs, regs->fred_ss.vector);
}

void __init fred_complete_exception_setup(void)
{
	unsigned int vector;

	for (vector = 0; vector < FIRST_EXTERNAL_VECTOR; vector++)
		set_bit(vector, system_vectors);

	for (vector = 0; vector < NR_SYSTEM_VECTORS; vector++) {
		if (sysvec_table[vector])
			set_bit(vector + FIRST_SYSTEM_VECTOR, system_vectors);
		else
			sysvec_table[vector] = fred_handle_spurious_interrupt;
	}
	fred_setup_done = true;
}

static noinstr void fred_extint(struct pt_regs *regs)
{
	unsigned int vector = regs->fred_ss.vector;
	unsigned int index = array_index_nospec(vector - FIRST_SYSTEM_VECTOR,
						NR_SYSTEM_VECTORS);

	if (WARN_ON_ONCE(vector < FIRST_EXTERNAL_VECTOR))
		return;

	if (likely(vector >= FIRST_SYSTEM_VECTOR)) {
		irqentry_state_t state = irqentry_enter(regs);

		instrumentation_begin();
		sysvec_table[index](regs);
		instrumentation_end();
		irqentry_exit(regs, state);
	} else {
		common_interrupt(regs, vector);
	}
}

static noinstr void fred_hwexc(struct pt_regs *regs, unsigned long error_code)
{
	/* Optimize for #PF. That's the only exception which matters performance wise */
	if (likely(regs->fred_ss.vector == X86_TRAP_PF))
		return exc_page_fault(regs, error_code);

	switch (regs->fred_ss.vector) {
	case X86_TRAP_DE: return exc_divide_error(regs);
	case X86_TRAP_DB: return fred_exc_debug(regs);
	case X86_TRAP_BR: return exc_bounds(regs);
	case X86_TRAP_UD: return exc_invalid_op(regs);
	case X86_TRAP_NM: return exc_device_not_available(regs);
	case X86_TRAP_DF: return exc_double_fault(regs, error_code);
	case X86_TRAP_TS: return exc_invalid_tss(regs, error_code);
	case X86_TRAP_NP: return exc_segment_not_present(regs, error_code);
	case X86_TRAP_SS: return exc_stack_segment(regs, error_code);
	case X86_TRAP_GP: return exc_general_protection(regs, error_code);
	case X86_TRAP_MF: return exc_coprocessor_error(regs);
	case X86_TRAP_AC: return exc_alignment_check(regs, error_code);
	case X86_TRAP_XF: return exc_simd_coprocessor_error(regs);

#ifdef CONFIG_X86_MCE
	case X86_TRAP_MC: return fred_exc_machine_check(regs);
#endif
#ifdef CONFIG_INTEL_TDX_GUEST
	case X86_TRAP_VE: return exc_virtualization_exception(regs);
#endif
#ifdef CONFIG_X86_CET
	case X86_TRAP_CP: return exc_control_protection(regs, error_code);
#endif
	default: return fred_bad_type(regs, error_code);
	}

}

static noinstr void fred_swexc(struct pt_regs *regs, unsigned long error_code)
{
	switch (regs->fred_ss.vector) {
	case X86_TRAP_BP: return exc_int3(regs);
	case X86_TRAP_OF: return exc_overflow(regs);
	default: return fred_bad_type(regs, error_code);
	}
}

__visible noinstr void fred_entry_from_user(struct pt_regs *regs)
{
	unsigned long error_code = regs->orig_ax;

	/* Invalidate orig_ax so that syscall_get_nr() works correctly */
	regs->orig_ax = -1;

	switch (regs->fred_ss.type) {
	case EVENT_TYPE_EXTINT:
		return fred_extint(regs);
	case EVENT_TYPE_NMI:
		if (likely(regs->fred_ss.vector == X86_TRAP_NMI))
			return fred_exc_nmi(regs);
		break;
	case EVENT_TYPE_HWEXC:
		return fred_hwexc(regs, error_code);
	case EVENT_TYPE_SWINT:
		return fred_intx(regs);
	case EVENT_TYPE_PRIV_SWEXC:
		if (likely(regs->fred_ss.vector == X86_TRAP_DB))
			return fred_exc_debug(regs);
		break;
	case EVENT_TYPE_SWEXC:
		return fred_swexc(regs, error_code);
	case EVENT_TYPE_OTHER:
		return fred_other(regs);
	default: break;
	}

	return fred_bad_type(regs, error_code);
}

__visible noinstr void fred_entry_from_kernel(struct pt_regs *regs)
{
	unsigned long error_code = regs->orig_ax;

	/* Invalidate orig_ax so that syscall_get_nr() works correctly */
	regs->orig_ax = -1;

	switch (regs->fred_ss.type) {
	case EVENT_TYPE_EXTINT:
		return fred_extint(regs);
	case EVENT_TYPE_NMI:
		if (likely(regs->fred_ss.vector == X86_TRAP_NMI))
			return fred_exc_nmi(regs);
		break;
	case EVENT_TYPE_HWEXC:
		return fred_hwexc(regs, error_code);
	case EVENT_TYPE_PRIV_SWEXC:
		if (likely(regs->fred_ss.vector == X86_TRAP_DB))
			return fred_exc_debug(regs);
		break;
	case EVENT_TYPE_SWEXC:
		return fred_swexc(regs, error_code);
	default: break;
	}

	return fred_bad_type(regs, error_code);
}

#if IS_ENABLED(CONFIG_KVM_INTEL)
__visible noinstr void __fred_entry_from_kvm(struct pt_regs *regs)
{
	switch (regs->fred_ss.type) {
	case EVENT_TYPE_EXTINT:
		return fred_extint(regs);
	case EVENT_TYPE_NMI:
		return fred_exc_nmi(regs);
	default:
		WARN_ON_ONCE(1);
	}
}
#endif