1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/module.h>
 
 
 
  3#include <asm/alternative.h>
  4#include <asm/facility.h>
  5#include <asm/nospec-branch.h>
  6
  7#define MAX_PATCH_LEN (255 - 1)
  8
  9static int __initdata_or_module alt_instr_disabled;
 10
 11static int __init disable_alternative_instructions(char *str)
 12{
 13	alt_instr_disabled = 1;
 14	return 0;
 15}
 16
 17early_param("noaltinstr", disable_alternative_instructions);
 18
 19struct brcl_insn {
 20	u16 opc;
 21	s32 disp;
 22} __packed;
 23
 24static u16 __initdata_or_module nop16 = 0x0700;
 25static u32 __initdata_or_module nop32 = 0x47000000;
 26static struct brcl_insn __initdata_or_module nop48 = {
 27	0xc004, 0
 28};
 29
 30static const void *nops[] __initdata_or_module = {
 31	&nop16,
 32	&nop32,
 33	&nop48
 34};
 35
 36static void __init_or_module add_jump_padding(void *insns, unsigned int len)
 37{
 38	struct brcl_insn brcl = {
 39		0xc0f4,
 40		len / 2
 41	};
 42
 43	memcpy(insns, &brcl, sizeof(brcl));
 44	insns += sizeof(brcl);
 45	len -= sizeof(brcl);
 46
 47	while (len > 0) {
 48		memcpy(insns, &nop16, 2);
 49		insns += 2;
 50		len -= 2;
 51	}
 52}
 53
 54static void __init_or_module add_padding(void *insns, unsigned int len)
 55{
 56	if (len > 6)
 57		add_jump_padding(insns, len);
 58	else if (len >= 2)
 59		memcpy(insns, nops[len / 2 - 1], len);
 60}
 61
 62static void __init_or_module __apply_alternatives(struct alt_instr *start,
 63						  struct alt_instr *end)
 64{
 65	struct alt_instr *a;
 66	u8 *instr, *replacement;
 67	u8 insnbuf[MAX_PATCH_LEN];
 68
 69	/*
 70	 * The scan order should be from start to end. A later scanned
 71	 * alternative code can overwrite previously scanned alternative code.
 72	 */
 73	for (a = start; a < end; a++) {
 74		int insnbuf_sz = 0;
 75
 76		instr = (u8 *)&a->instr_offset + a->instr_offset;
 77		replacement = (u8 *)&a->repl_offset + a->repl_offset;
 78
 79		if (!__test_facility(a->facility,
 80				     S390_lowcore.alt_stfle_fac_list))
 81			continue;
 82
 83		if (unlikely(a->instrlen % 2 || a->replacementlen % 2)) {
 84			WARN_ONCE(1, "cpu alternatives instructions length is "
 85				     "odd, skipping patching\n");
 86			continue;
 87		}
 88
 89		memcpy(insnbuf, replacement, a->replacementlen);
 90		insnbuf_sz = a->replacementlen;
 91
 92		if (a->instrlen > a->replacementlen) {
 93			add_padding(insnbuf + a->replacementlen,
 94				    a->instrlen - a->replacementlen);
 95			insnbuf_sz += a->instrlen - a->replacementlen;
 96		}
 97
 98		s390_kernel_write(instr, insnbuf, insnbuf_sz);
 99	}
100}
101
102void __init_or_module apply_alternatives(struct alt_instr *start,
103					 struct alt_instr *end)
104{
105	if (!alt_instr_disabled)
106		__apply_alternatives(start, end);
107}
108
109extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
110void __init apply_alternative_instructions(void)
111{
112	apply_alternatives(__alt_instructions, __alt_instructions_end);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
113}

 1// SPDX-License-Identifier: GPL-2.0
 2#include <linux/module.h>
 3#include <linux/cpu.h>
 4#include <linux/smp.h>
 5#include <asm/text-patching.h>
 6#include <asm/alternative.h>
 7#include <asm/facility.h>
 8#include <asm/nospec-branch.h>
 9
 
 
10static int __initdata_or_module alt_instr_disabled;
11
12static int __init disable_alternative_instructions(char *str)
13{
14	alt_instr_disabled = 1;
15	return 0;
16}
17
18early_param("noaltinstr", disable_alternative_instructions);
19
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
20static void __init_or_module __apply_alternatives(struct alt_instr *start,
21						  struct alt_instr *end)
22{
23	struct alt_instr *a;
24	u8 *instr, *replacement;
 
25
26	/*
27	 * The scan order should be from start to end. A later scanned
28	 * alternative code can overwrite previously scanned alternative code.
29	 */
30	for (a = start; a < end; a++) {
 
 
31		instr = (u8 *)&a->instr_offset + a->instr_offset;
32		replacement = (u8 *)&a->repl_offset + a->repl_offset;
33
34		if (!__test_facility(a->facility, alt_stfle_fac_list))
 
35			continue;
36
37		if (unlikely(a->instrlen % 2)) {
38			WARN_ONCE(1, "cpu alternatives instructions length is "
39				     "odd, skipping patching\n");
40			continue;
41		}
42
43		s390_kernel_write(instr, replacement, a->instrlen);
 
 
 
 
 
 
 
 
 
44	}
45}
46
47void __init_or_module apply_alternatives(struct alt_instr *start,
48					 struct alt_instr *end)
49{
50	if (!alt_instr_disabled)
51		__apply_alternatives(start, end);
52}
53
54extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
55void __init apply_alternative_instructions(void)
56{
57	apply_alternatives(__alt_instructions, __alt_instructions_end);
58}
59
60static void do_sync_core(void *info)
61{
62	sync_core();
63}
64
65void text_poke_sync(void)
66{
67	on_each_cpu(do_sync_core, NULL, 1);
68}
69
70void text_poke_sync_lock(void)
71{
72	cpus_read_lock();
73	text_poke_sync();
74	cpus_read_unlock();
75}