Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * jump label x86 support
4 : : *
5 : : * Copyright (C) 2009 Jason Baron <jbaron@redhat.com>
6 : : *
7 : : */
8 : : #include <linux/jump_label.h>
9 : : #include <linux/memory.h>
10 : : #include <linux/uaccess.h>
11 : : #include <linux/module.h>
12 : : #include <linux/list.h>
13 : : #include <linux/jhash.h>
14 : : #include <linux/cpu.h>
15 : : #include <asm/kprobes.h>
16 : : #include <asm/alternative.h>
17 : : #include <asm/text-patching.h>
18 : :
19 : 0 : static void bug_at(const void *ip, int line)
20 : : {
21 : : /*
22 : : * The location is not an op that we were expecting.
23 : : * Something went wrong. Crash the box, as something could be
24 : : * corrupting the kernel.
25 : : */
26 : 0 : pr_crit("jump_label: Fatal kernel bug, unexpected op at %pS [%p] (%5ph) %d\n", ip, ip, ip, line);
27 : 0 : BUG();
28 : : }
29 : :
30 : : static const void *
31 : 92456 : __jump_label_set_jump_code(struct jump_entry *entry, enum jump_label_type type, int init)
32 : : {
33 : 92456 : const unsigned char default_nop[] = { STATIC_KEY_INIT_NOP };
34 : 92456 : const unsigned char *ideal_nop = ideal_nops[NOP_ATOMIC5];
35 : 92456 : const void *expect, *code;
36 : 92456 : const void *addr, *dest;
37 : 92456 : int line;
38 : :
39 [ + + ]: 92456 : addr = (void *)jump_entry_code(entry);
40 [ + + ]: 92456 : dest = (void *)jump_entry_target(entry);
41 : :
42 [ + + ]: 92456 : code = text_gen_insn(JMP32_INSN_OPCODE, addr, dest);
43 : :
44 [ + + ]: 92456 : if (init) {
45 : : expect = default_nop; line = __LINE__;
46 [ + + ]: 1708 : } else if (type == JUMP_LABEL_JMP) {
47 : : expect = ideal_nop; line = __LINE__;
48 : : } else {
49 : 560 : expect = code; line = __LINE__;
50 : : }
51 : :
52 [ - + ]: 92456 : if (memcmp(addr, expect, JUMP_LABEL_NOP_SIZE))
53 : 0 : bug_at(addr, line);
54 : :
55 [ + + ]: 92456 : if (type == JUMP_LABEL_NOP)
56 : 91308 : code = ideal_nop;
57 : :
58 : 92456 : return code;
59 : : }
60 : :
61 : 90916 : static void inline __jump_label_transform(struct jump_entry *entry,
62 : : enum jump_label_type type,
63 : : int init)
64 : : {
65 : 90916 : const void *opcode = __jump_label_set_jump_code(entry, type, init);
66 : :
67 : : /*
68 : : * As long as only a single processor is running and the code is still
69 : : * not marked as RO, text_poke_early() can be used; Checking that
70 : : * system_state is SYSTEM_BOOTING guarantees it. It will be set to
71 : : * SYSTEM_SCHEDULING before other cores are awaken and before the
72 : : * code is write-protected.
73 : : *
74 : : * At the time the change is being done, just ignore whether we
75 : : * are doing nop -> jump or jump -> nop transition, and assume
76 : : * always nop being the 'currently valid' instruction
77 : : */
78 [ + + + - ]: 90916 : if (init || system_state == SYSTEM_BOOTING) {
79 : 90916 : text_poke_early((void *)jump_entry_code(entry), opcode,
80 : : JUMP_LABEL_NOP_SIZE);
81 : 90916 : return;
82 : : }
83 : :
84 : 0 : text_poke_bp((void *)jump_entry_code(entry), opcode, JUMP_LABEL_NOP_SIZE, NULL);
85 : : }
86 : :
87 : 90916 : static void __ref jump_label_transform(struct jump_entry *entry,
88 : : enum jump_label_type type,
89 : : int init)
90 : : {
91 : 90916 : mutex_lock(&text_mutex);
92 : 90916 : __jump_label_transform(entry, type, init);
93 : 90916 : mutex_unlock(&text_mutex);
94 : 90916 : }
95 : :
96 : 168 : void arch_jump_label_transform(struct jump_entry *entry,
97 : : enum jump_label_type type)
98 : : {
99 : 0 : jump_label_transform(entry, type, 0);
100 : 0 : }
101 : :
102 : 1708 : bool arch_jump_label_transform_queue(struct jump_entry *entry,
103 : : enum jump_label_type type)
104 : : {
105 : 1708 : const void *opcode;
106 : :
107 [ + + ]: 1708 : if (system_state == SYSTEM_BOOTING) {
108 : : /*
109 : : * Fallback to the non-batching mode.
110 : : */
111 : 168 : arch_jump_label_transform(entry, type);
112 : 168 : return true;
113 : : }
114 : :
115 : 1540 : mutex_lock(&text_mutex);
116 : 1540 : opcode = __jump_label_set_jump_code(entry, type, 0);
117 : 1540 : text_poke_queue((void *)jump_entry_code(entry),
118 : : opcode, JUMP_LABEL_NOP_SIZE, NULL);
119 : 1540 : mutex_unlock(&text_mutex);
120 : 1540 : return true;
121 : : }
122 : :
123 : 532 : void arch_jump_label_transform_apply(void)
124 : : {
125 : 532 : mutex_lock(&text_mutex);
126 : 532 : text_poke_finish();
127 : 532 : mutex_unlock(&text_mutex);
128 : 532 : }
129 : :
130 : : static enum {
131 : : JL_STATE_START,
132 : : JL_STATE_NO_UPDATE,
133 : : JL_STATE_UPDATE,
134 : : } jlstate __initdata_or_module = JL_STATE_START;
135 : :
136 : 90748 : __init_or_module void arch_jump_label_transform_static(struct jump_entry *entry,
137 : : enum jump_label_type type)
138 : : {
139 : : /*
140 : : * This function is called at boot up and when modules are
141 : : * first loaded. Check if the default nop, the one that is
142 : : * inserted at compile time, is the ideal nop. If it is, then
143 : : * we do not need to update the nop, and we can leave it as is.
144 : : * If it is not, then we need to update the nop to the ideal nop.
145 : : */
146 [ + + ]: 90748 : if (jlstate == JL_STATE_START) {
147 : 28 : const unsigned char default_nop[] = { STATIC_KEY_INIT_NOP };
148 : 28 : const unsigned char *ideal_nop = ideal_nops[NOP_ATOMIC5];
149 : :
150 [ + - ]: 28 : if (memcmp(ideal_nop, default_nop, 5) != 0)
151 : 28 : jlstate = JL_STATE_UPDATE;
152 : : else
153 : 0 : jlstate = JL_STATE_NO_UPDATE;
154 : : }
155 [ + - ]: 90748 : if (jlstate == JL_STATE_UPDATE)
156 : 90748 : jump_label_transform(entry, type, 1);
157 : 90748 : }
|
