[mirror_ubuntu-bionic-kernel.git] / arch / s390 / kernel / alternative.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/module.h>
#include <asm/alternative.h>
#include <asm/facility.h>
#include <asm/nospec-branch.h>

#define MAX_PATCH_LEN (255 - 1)

static int __initdata_or_module alt_instr_disabled;

static int __init disable_alternative_instructions(char *str)
{
	alt_instr_disabled = 1;
	return 0;
}

early_param("noaltinstr", disable_alternative_instructions);

struct brcl_insn {
	u16 opc;
	s32 disp;
} __packed;

static u16 __initdata_or_module nop16 = 0x0700;
static u32 __initdata_or_module nop32 = 0x47000000;
static struct brcl_insn __initdata_or_module nop48 = {
	0xc004, 0
};

static const void *nops[] __initdata_or_module = {
	&nop16,
	&nop32,
	&nop48
};

static void __init_or_module add_jump_padding(void *insns, unsigned int len)
{
	struct brcl_insn brcl = {
		0xc0f4,
		len / 2
	};

	memcpy(insns, &brcl, sizeof(brcl));
	insns += sizeof(brcl);
	len -= sizeof(brcl);

	while (len > 0) {
		memcpy(insns, &nop16, 2);
		insns += 2;
		len -= 2;
	}
}

static void __init_or_module add_padding(void *insns, unsigned int len)
{
	if (len > 6)
		add_jump_padding(insns, len);
	else if (len >= 2)
		memcpy(insns, nops[len / 2 - 1], len);
}

static void __init_or_module __apply_alternatives(struct alt_instr *start,
						  struct alt_instr *end)
{
	struct alt_instr *a;
	u8 *instr, *replacement;
	u8 insnbuf[MAX_PATCH_LEN];

	/*
	 * The scan order should be from start to end. A later scanned
	 * alternative code can overwrite previously scanned alternative code.
	 */
	for (a = start; a < end; a++) {
		int insnbuf_sz = 0;

		instr = (u8 *)&a->instr_offset + a->instr_offset;
		replacement = (u8 *)&a->repl_offset + a->repl_offset;

		if (!__test_facility(a->facility,
				     S390_lowcore.alt_stfle_fac_list))
			continue;

		if (unlikely(a->instrlen % 2 || a->replacementlen % 2)) {
			WARN_ONCE(1, "cpu alternatives instructions length is "
				     "odd, skipping patching\n");
			continue;
		}

		memcpy(insnbuf, replacement, a->replacementlen);
		insnbuf_sz = a->replacementlen;

		if (a->instrlen > a->replacementlen) {
			add_padding(insnbuf + a->replacementlen,
				    a->instrlen - a->replacementlen);
			insnbuf_sz += a->instrlen - a->replacementlen;
		}

		s390_kernel_write(instr, insnbuf, insnbuf_sz);
	}
}

void __init_or_module apply_alternatives(struct alt_instr *start,
					 struct alt_instr *end)
{
	if (!alt_instr_disabled)
		__apply_alternatives(start, end);
}

extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
void __init apply_alternative_instructions(void)
{
	apply_alternatives(__alt_instructions, __alt_instructions_end);
}
Commit	Line	Data
9fa1db4c	1	// SPDX-License-Identifier: GPL-2.0
686140a1 VG	2	#include <linux/module.h>
	3	#include <asm/alternative.h>
	4	#include <asm/facility.h>
3eb01835	5	#include <asm/nospec-branch.h>
686140a1 VG	6
	7	#define MAX_PATCH_LEN (255 - 1)
	8
	9	static int __initdata_or_module alt_instr_disabled;
	10
	11	static int __init disable_alternative_instructions(char *str)
	12	{
	13	alt_instr_disabled = 1;
	14	return 0;
	15	}
	16
	17	early_param("noaltinstr", disable_alternative_instructions);
	18
	19	struct brcl_insn {
	20	u16 opc;
	21	s32 disp;
	22	} __packed;
	23
	24	static u16 __initdata_or_module nop16 = 0x0700;
	25	static u32 __initdata_or_module nop32 = 0x47000000;
	26	static struct brcl_insn __initdata_or_module nop48 = {
	27	0xc004, 0
	28	};
	29
	30	static const void *nops[] __initdata_or_module = {
	31	&nop16,
	32	&nop32,
	33	&nop48
	34	};
	35
	36	static 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
	54	static 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
	62	static 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
db2b5991 MS	79	if (!__test_facility(a->facility,
db2b5991 MS	80	S390_lowcore.alt_stfle_fac_list))
686140a1 VG	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
	102	void __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
	109	extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
	110	void __init apply_alternative_instructions(void)
	111	{
	112	apply_alternatives(__alt_instructions, __alt_instructions_end);
	113	}