xref: /linux/arch/powerpc/lib/code-patching.c (revision 4549c3ea3160fa8b3f37dfe2f957657bb265eda9)
12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2aaddd3eaSMichael Ellerman /*
3aaddd3eaSMichael Ellerman  *  Copyright 2008 Michael Ellerman, IBM Corporation.
4aaddd3eaSMichael Ellerman  */
5aaddd3eaSMichael Ellerman 
6aaddd3eaSMichael Ellerman #include <linux/kernel.h>
771f6e58eSNaveen N. Rao #include <linux/kprobes.h>
8ae0dc736SMichael Ellerman #include <linux/vmalloc.h>
9ae0dc736SMichael Ellerman #include <linux/init.h>
1027ac792cSAndrea Righi #include <linux/mm.h>
1137bc3e5fSBalbir Singh #include <linux/cpuhotplug.h>
1237bc3e5fSBalbir Singh #include <linux/slab.h>
137c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
14aaddd3eaSMichael Ellerman 
1537bc3e5fSBalbir Singh #include <asm/tlbflush.h>
1637bc3e5fSBalbir Singh #include <asm/page.h>
1737bc3e5fSBalbir Singh #include <asm/code-patching.h>
18252eb558SChristophe Leroy #include <asm/setup.h>
1975346251SJordan Niethe #include <asm/inst.h>
20aaddd3eaSMichael Ellerman 
2169d4d6e5SChristophe Leroy static int __patch_instruction(u32 *exec_addr, struct ppc_inst instr, u32 *patch_addr)
22aaddd3eaSMichael Ellerman {
23e63ceebdSChristophe Leroy 	if (!ppc_inst_prefixed(instr)) {
24e63ceebdSChristophe Leroy 		u32 val = ppc_inst_val(instr);
25e63ceebdSChristophe Leroy 
26e63ceebdSChristophe Leroy 		__put_kernel_nofault(patch_addr, &val, u32, failed);
27e63ceebdSChristophe Leroy 	} else {
28693557ebSChristophe Leroy 		u64 val = ppc_inst_as_ulong(instr);
29e63ceebdSChristophe Leroy 
30e63ceebdSChristophe Leroy 		__put_kernel_nofault(patch_addr, &val, u64, failed);
31e63ceebdSChristophe Leroy 	}
3237bc3e5fSBalbir Singh 
338cf4c057SChristophe Leroy 	asm ("dcbst 0, %0; sync; icbi 0,%1; sync; isync" :: "r" (patch_addr),
348cf4c057SChristophe Leroy 							    "r" (exec_addr));
3537bc3e5fSBalbir Singh 
36b6e37968SSteven Rostedt 	return 0;
37e64ac41aSChristophe Leroy 
38e64ac41aSChristophe Leroy failed:
39e64ac41aSChristophe Leroy 	return -EFAULT;
40aaddd3eaSMichael Ellerman }
41aaddd3eaSMichael Ellerman 
4269d4d6e5SChristophe Leroy int raw_patch_instruction(u32 *addr, struct ppc_inst instr)
438cf4c057SChristophe Leroy {
448cf4c057SChristophe Leroy 	return __patch_instruction(addr, instr, addr);
458cf4c057SChristophe Leroy }
468cf4c057SChristophe Leroy 
4737bc3e5fSBalbir Singh #ifdef CONFIG_STRICT_KERNEL_RWX
4837bc3e5fSBalbir Singh static DEFINE_PER_CPU(struct vm_struct *, text_poke_area);
4937bc3e5fSBalbir Singh 
5037bc3e5fSBalbir Singh static int text_area_cpu_up(unsigned int cpu)
5137bc3e5fSBalbir Singh {
5237bc3e5fSBalbir Singh 	struct vm_struct *area;
5337bc3e5fSBalbir Singh 
5437bc3e5fSBalbir Singh 	area = get_vm_area(PAGE_SIZE, VM_ALLOC);
5537bc3e5fSBalbir Singh 	if (!area) {
5637bc3e5fSBalbir Singh 		WARN_ONCE(1, "Failed to create text area for cpu %d\n",
5737bc3e5fSBalbir Singh 			cpu);
5837bc3e5fSBalbir Singh 		return -1;
5937bc3e5fSBalbir Singh 	}
6037bc3e5fSBalbir Singh 	this_cpu_write(text_poke_area, area);
6137bc3e5fSBalbir Singh 
6237bc3e5fSBalbir Singh 	return 0;
6337bc3e5fSBalbir Singh }
6437bc3e5fSBalbir Singh 
6537bc3e5fSBalbir Singh static int text_area_cpu_down(unsigned int cpu)
6637bc3e5fSBalbir Singh {
6737bc3e5fSBalbir Singh 	free_vm_area(this_cpu_read(text_poke_area));
6837bc3e5fSBalbir Singh 	return 0;
6937bc3e5fSBalbir Singh }
7037bc3e5fSBalbir Singh 
7137bc3e5fSBalbir Singh /*
7271a5b3dbSJordan Niethe  * Although BUG_ON() is rude, in this case it should only happen if ENOMEM, and
7371a5b3dbSJordan Niethe  * we judge it as being preferable to a kernel that will crash later when
7471a5b3dbSJordan Niethe  * someone tries to use patch_instruction().
7537bc3e5fSBalbir Singh  */
7671a5b3dbSJordan Niethe void __init poking_init(void)
7737bc3e5fSBalbir Singh {
7837bc3e5fSBalbir Singh 	BUG_ON(!cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
7937bc3e5fSBalbir Singh 		"powerpc/text_poke:online", text_area_cpu_up,
8037bc3e5fSBalbir Singh 		text_area_cpu_down));
8137bc3e5fSBalbir Singh }
8237bc3e5fSBalbir Singh 
8337bc3e5fSBalbir Singh /*
8437bc3e5fSBalbir Singh  * This can be called for kernel text or a module.
8537bc3e5fSBalbir Singh  */
8637bc3e5fSBalbir Singh static int map_patch_area(void *addr, unsigned long text_poke_addr)
8737bc3e5fSBalbir Singh {
8837bc3e5fSBalbir Singh 	unsigned long pfn;
8937bc3e5fSBalbir Singh 	int err;
9037bc3e5fSBalbir Singh 
91ccc8fcf7SChristophe Leroy 	if (is_vmalloc_or_module_addr(addr))
9237bc3e5fSBalbir Singh 		pfn = vmalloc_to_pfn(addr);
9337bc3e5fSBalbir Singh 	else
9437bc3e5fSBalbir Singh 		pfn = __pa_symbol(addr) >> PAGE_SHIFT;
9537bc3e5fSBalbir Singh 
96c766ee72SChristophe Leroy 	err = map_kernel_page(text_poke_addr, (pfn << PAGE_SHIFT), PAGE_KERNEL);
9737bc3e5fSBalbir Singh 
9837bc3e5fSBalbir Singh 	pr_devel("Mapped addr %lx with pfn %lx:%d\n", text_poke_addr, pfn, err);
9937bc3e5fSBalbir Singh 	if (err)
10037bc3e5fSBalbir Singh 		return -1;
10137bc3e5fSBalbir Singh 
10237bc3e5fSBalbir Singh 	return 0;
10337bc3e5fSBalbir Singh }
10437bc3e5fSBalbir Singh 
10537bc3e5fSBalbir Singh static inline int unmap_patch_area(unsigned long addr)
10637bc3e5fSBalbir Singh {
10737bc3e5fSBalbir Singh 	pte_t *ptep;
10837bc3e5fSBalbir Singh 	pmd_t *pmdp;
10937bc3e5fSBalbir Singh 	pud_t *pudp;
1102fb47060SMike Rapoport 	p4d_t *p4dp;
11137bc3e5fSBalbir Singh 	pgd_t *pgdp;
11237bc3e5fSBalbir Singh 
11337bc3e5fSBalbir Singh 	pgdp = pgd_offset_k(addr);
11437bc3e5fSBalbir Singh 	if (unlikely(!pgdp))
11537bc3e5fSBalbir Singh 		return -EINVAL;
11637bc3e5fSBalbir Singh 
1172fb47060SMike Rapoport 	p4dp = p4d_offset(pgdp, addr);
1182fb47060SMike Rapoport 	if (unlikely(!p4dp))
1192fb47060SMike Rapoport 		return -EINVAL;
1202fb47060SMike Rapoport 
1212fb47060SMike Rapoport 	pudp = pud_offset(p4dp, addr);
12237bc3e5fSBalbir Singh 	if (unlikely(!pudp))
12337bc3e5fSBalbir Singh 		return -EINVAL;
12437bc3e5fSBalbir Singh 
12537bc3e5fSBalbir Singh 	pmdp = pmd_offset(pudp, addr);
12637bc3e5fSBalbir Singh 	if (unlikely(!pmdp))
12737bc3e5fSBalbir Singh 		return -EINVAL;
12837bc3e5fSBalbir Singh 
12937bc3e5fSBalbir Singh 	ptep = pte_offset_kernel(pmdp, addr);
13037bc3e5fSBalbir Singh 	if (unlikely(!ptep))
13137bc3e5fSBalbir Singh 		return -EINVAL;
13237bc3e5fSBalbir Singh 
13337bc3e5fSBalbir Singh 	pr_devel("clearing mm %p, pte %p, addr %lx\n", &init_mm, ptep, addr);
13437bc3e5fSBalbir Singh 
13537bc3e5fSBalbir Singh 	/*
13637bc3e5fSBalbir Singh 	 * In hash, pte_clear flushes the tlb, in radix, we have to
13737bc3e5fSBalbir Singh 	 */
13837bc3e5fSBalbir Singh 	pte_clear(&init_mm, addr, ptep);
13937bc3e5fSBalbir Singh 	flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
14037bc3e5fSBalbir Singh 
14137bc3e5fSBalbir Singh 	return 0;
14237bc3e5fSBalbir Singh }
14337bc3e5fSBalbir Singh 
14469d4d6e5SChristophe Leroy static int do_patch_instruction(u32 *addr, struct ppc_inst instr)
14537bc3e5fSBalbir Singh {
14637bc3e5fSBalbir Singh 	int err;
14769d4d6e5SChristophe Leroy 	u32 *patch_addr = NULL;
14837bc3e5fSBalbir Singh 	unsigned long flags;
14937bc3e5fSBalbir Singh 	unsigned long text_poke_addr;
15037bc3e5fSBalbir Singh 	unsigned long kaddr = (unsigned long)addr;
15137bc3e5fSBalbir Singh 
15237bc3e5fSBalbir Singh 	/*
15337bc3e5fSBalbir Singh 	 * During early early boot patch_instruction is called
15437bc3e5fSBalbir Singh 	 * when text_poke_area is not ready, but we still need
15537bc3e5fSBalbir Singh 	 * to allow patching. We just do the plain old patching
15637bc3e5fSBalbir Singh 	 */
1578183d99fSChristophe Leroy 	if (!this_cpu_read(text_poke_area))
1588cf4c057SChristophe Leroy 		return raw_patch_instruction(addr, instr);
15937bc3e5fSBalbir Singh 
16037bc3e5fSBalbir Singh 	local_irq_save(flags);
16137bc3e5fSBalbir Singh 
16237bc3e5fSBalbir Singh 	text_poke_addr = (unsigned long)__this_cpu_read(text_poke_area)->addr;
16337bc3e5fSBalbir Singh 	if (map_patch_area(addr, text_poke_addr)) {
16437bc3e5fSBalbir Singh 		err = -1;
16537bc3e5fSBalbir Singh 		goto out;
16637bc3e5fSBalbir Singh 	}
16737bc3e5fSBalbir Singh 
16869d4d6e5SChristophe Leroy 	patch_addr = (u32 *)(text_poke_addr + (kaddr & ~PAGE_MASK));
16937bc3e5fSBalbir Singh 
1708cf4c057SChristophe Leroy 	__patch_instruction(addr, instr, patch_addr);
17137bc3e5fSBalbir Singh 
17237bc3e5fSBalbir Singh 	err = unmap_patch_area(text_poke_addr);
17337bc3e5fSBalbir Singh 	if (err)
17437bc3e5fSBalbir Singh 		pr_warn("failed to unmap %lx\n", text_poke_addr);
17537bc3e5fSBalbir Singh 
17637bc3e5fSBalbir Singh out:
17737bc3e5fSBalbir Singh 	local_irq_restore(flags);
17837bc3e5fSBalbir Singh 
17937bc3e5fSBalbir Singh 	return err;
18037bc3e5fSBalbir Singh }
18137bc3e5fSBalbir Singh #else /* !CONFIG_STRICT_KERNEL_RWX */
18237bc3e5fSBalbir Singh 
18369d4d6e5SChristophe Leroy static int do_patch_instruction(u32 *addr, struct ppc_inst instr)
18437bc3e5fSBalbir Singh {
1858cf4c057SChristophe Leroy 	return raw_patch_instruction(addr, instr);
18637bc3e5fSBalbir Singh }
18737bc3e5fSBalbir Singh 
18837bc3e5fSBalbir Singh #endif /* CONFIG_STRICT_KERNEL_RWX */
189b45ba4a5SChristophe Leroy 
19069d4d6e5SChristophe Leroy int patch_instruction(u32 *addr, struct ppc_inst instr)
191b45ba4a5SChristophe Leroy {
192b45ba4a5SChristophe Leroy 	/* Make sure we aren't patching a freed init section */
193b45ba4a5SChristophe Leroy 	if (init_mem_is_free && init_section_contains(addr, 4)) {
194b45ba4a5SChristophe Leroy 		pr_debug("Skipping init section patching addr: 0x%px\n", addr);
195b45ba4a5SChristophe Leroy 		return 0;
196b45ba4a5SChristophe Leroy 	}
197b45ba4a5SChristophe Leroy 	return do_patch_instruction(addr, instr);
198b45ba4a5SChristophe Leroy }
19937bc3e5fSBalbir Singh NOKPROBE_SYMBOL(patch_instruction);
20037bc3e5fSBalbir Singh 
20169d4d6e5SChristophe Leroy int patch_branch(u32 *addr, unsigned long target, int flags)
202e7a57273SMichael Ellerman {
20394afd069SJordan Niethe 	struct ppc_inst instr;
2047c95d889SJordan Niethe 
2057c95d889SJordan Niethe 	create_branch(&instr, addr, target, flags);
2067c95d889SJordan Niethe 	return patch_instruction(addr, instr);
207e7a57273SMichael Ellerman }
208e7a57273SMichael Ellerman 
209ebfa50dfSAnju T bool is_offset_in_branch_range(long offset)
210ebfa50dfSAnju T {
211ebfa50dfSAnju T 	/*
212ebfa50dfSAnju T 	 * Powerpc branch instruction is :
213ebfa50dfSAnju T 	 *
214ebfa50dfSAnju T 	 *  0         6                 30   31
215ebfa50dfSAnju T 	 *  +---------+----------------+---+---+
216ebfa50dfSAnju T 	 *  | opcode  |     LI         |AA |LK |
217ebfa50dfSAnju T 	 *  +---------+----------------+---+---+
218ebfa50dfSAnju T 	 *  Where AA = 0 and LK = 0
219ebfa50dfSAnju T 	 *
220ebfa50dfSAnju T 	 * LI is a signed 24 bits integer. The real branch offset is computed
221ebfa50dfSAnju T 	 * by: imm32 = SignExtend(LI:'0b00', 32);
222ebfa50dfSAnju T 	 *
223ebfa50dfSAnju T 	 * So the maximum forward branch should be:
224ebfa50dfSAnju T 	 *   (0x007fffff << 2) = 0x01fffffc =  0x1fffffc
225ebfa50dfSAnju T 	 * The maximum backward branch should be:
226ebfa50dfSAnju T 	 *   (0xff800000 << 2) = 0xfe000000 = -0x2000000
227ebfa50dfSAnju T 	 */
228ebfa50dfSAnju T 	return (offset >= -0x2000000 && offset <= 0x1fffffc && !(offset & 0x3));
229ebfa50dfSAnju T }
230ebfa50dfSAnju T 
231*4549c3eaSNaveen N. Rao bool is_offset_in_cond_branch_range(long offset)
232*4549c3eaSNaveen N. Rao {
233*4549c3eaSNaveen N. Rao 	return offset >= -0x8000 && offset <= 0x7fff && !(offset & 0x3);
234*4549c3eaSNaveen N. Rao }
235*4549c3eaSNaveen N. Rao 
23651c9c084SAnju T /*
23751c9c084SAnju T  * Helper to check if a given instruction is a conditional branch
23851c9c084SAnju T  * Derived from the conditional checks in analyse_instr()
23951c9c084SAnju T  */
24094afd069SJordan Niethe bool is_conditional_branch(struct ppc_inst instr)
24151c9c084SAnju T {
2428094892dSJordan Niethe 	unsigned int opcode = ppc_inst_primary_opcode(instr);
24351c9c084SAnju T 
24451c9c084SAnju T 	if (opcode == 16)       /* bc, bca, bcl, bcla */
24551c9c084SAnju T 		return true;
24651c9c084SAnju T 	if (opcode == 19) {
247777e26f0SJordan Niethe 		switch ((ppc_inst_val(instr) >> 1) & 0x3ff) {
24851c9c084SAnju T 		case 16:        /* bclr, bclrl */
24951c9c084SAnju T 		case 528:       /* bcctr, bcctrl */
25051c9c084SAnju T 		case 560:       /* bctar, bctarl */
25151c9c084SAnju T 			return true;
25251c9c084SAnju T 		}
25351c9c084SAnju T 	}
25451c9c084SAnju T 	return false;
25551c9c084SAnju T }
25671f6e58eSNaveen N. Rao NOKPROBE_SYMBOL(is_conditional_branch);
25751c9c084SAnju T 
25869d4d6e5SChristophe Leroy int create_branch(struct ppc_inst *instr, const u32 *addr,
259e7a57273SMichael Ellerman 		  unsigned long target, int flags)
260aaddd3eaSMichael Ellerman {
261053a858eSMichael Ellerman 	long offset;
262aaddd3eaSMichael Ellerman 
26394afd069SJordan Niethe 	*instr = ppc_inst(0);
264053a858eSMichael Ellerman 	offset = target;
265aaddd3eaSMichael Ellerman 	if (! (flags & BRANCH_ABSOLUTE))
266053a858eSMichael Ellerman 		offset = offset - (unsigned long)addr;
267053a858eSMichael Ellerman 
268053a858eSMichael Ellerman 	/* Check we can represent the target in the instruction format */
269ebfa50dfSAnju T 	if (!is_offset_in_branch_range(offset))
2707c95d889SJordan Niethe 		return 1;
271aaddd3eaSMichael Ellerman 
272aaddd3eaSMichael Ellerman 	/* Mask out the flags and target, so they don't step on each other. */
27394afd069SJordan Niethe 	*instr = ppc_inst(0x48000000 | (flags & 0x3) | (offset & 0x03FFFFFC));
274aaddd3eaSMichael Ellerman 
2757c95d889SJordan Niethe 	return 0;
276aaddd3eaSMichael Ellerman }
277411781a2SMichael Ellerman 
27869d4d6e5SChristophe Leroy int create_cond_branch(struct ppc_inst *instr, const u32 *addr,
279411781a2SMichael Ellerman 		       unsigned long target, int flags)
280411781a2SMichael Ellerman {
281411781a2SMichael Ellerman 	long offset;
282411781a2SMichael Ellerman 
283411781a2SMichael Ellerman 	offset = target;
284411781a2SMichael Ellerman 	if (! (flags & BRANCH_ABSOLUTE))
285411781a2SMichael Ellerman 		offset = offset - (unsigned long)addr;
286411781a2SMichael Ellerman 
287411781a2SMichael Ellerman 	/* Check we can represent the target in the instruction format */
288*4549c3eaSNaveen N. Rao 	if (!is_offset_in_cond_branch_range(offset))
2897c95d889SJordan Niethe 		return 1;
290411781a2SMichael Ellerman 
291411781a2SMichael Ellerman 	/* Mask out the flags and target, so they don't step on each other. */
29294afd069SJordan Niethe 	*instr = ppc_inst(0x40000000 | (flags & 0x3FF0003) | (offset & 0xFFFC));
293411781a2SMichael Ellerman 
2947c95d889SJordan Niethe 	return 0;
295411781a2SMichael Ellerman }
296411781a2SMichael Ellerman 
29794afd069SJordan Niethe static unsigned int branch_opcode(struct ppc_inst instr)
298411781a2SMichael Ellerman {
2998094892dSJordan Niethe 	return ppc_inst_primary_opcode(instr) & 0x3F;
300411781a2SMichael Ellerman }
301411781a2SMichael Ellerman 
30294afd069SJordan Niethe static int instr_is_branch_iform(struct ppc_inst instr)
303411781a2SMichael Ellerman {
304411781a2SMichael Ellerman 	return branch_opcode(instr) == 18;
305411781a2SMichael Ellerman }
306411781a2SMichael Ellerman 
30794afd069SJordan Niethe static int instr_is_branch_bform(struct ppc_inst instr)
308411781a2SMichael Ellerman {
309411781a2SMichael Ellerman 	return branch_opcode(instr) == 16;
310411781a2SMichael Ellerman }
311411781a2SMichael Ellerman 
31294afd069SJordan Niethe int instr_is_relative_branch(struct ppc_inst instr)
313411781a2SMichael Ellerman {
314777e26f0SJordan Niethe 	if (ppc_inst_val(instr) & BRANCH_ABSOLUTE)
315411781a2SMichael Ellerman 		return 0;
316411781a2SMichael Ellerman 
317411781a2SMichael Ellerman 	return instr_is_branch_iform(instr) || instr_is_branch_bform(instr);
318411781a2SMichael Ellerman }
319411781a2SMichael Ellerman 
32094afd069SJordan Niethe int instr_is_relative_link_branch(struct ppc_inst instr)
321b9eab08dSJosh Poimboeuf {
322777e26f0SJordan Niethe 	return instr_is_relative_branch(instr) && (ppc_inst_val(instr) & BRANCH_SET_LINK);
323b9eab08dSJosh Poimboeuf }
324b9eab08dSJosh Poimboeuf 
32569d4d6e5SChristophe Leroy static unsigned long branch_iform_target(const u32 *instr)
326411781a2SMichael Ellerman {
327411781a2SMichael Ellerman 	signed long imm;
328411781a2SMichael Ellerman 
32918c85964SChristophe Leroy 	imm = ppc_inst_val(ppc_inst_read(instr)) & 0x3FFFFFC;
330411781a2SMichael Ellerman 
331411781a2SMichael Ellerman 	/* If the top bit of the immediate value is set this is negative */
332411781a2SMichael Ellerman 	if (imm & 0x2000000)
333411781a2SMichael Ellerman 		imm -= 0x4000000;
334411781a2SMichael Ellerman 
33518c85964SChristophe Leroy 	if ((ppc_inst_val(ppc_inst_read(instr)) & BRANCH_ABSOLUTE) == 0)
336411781a2SMichael Ellerman 		imm += (unsigned long)instr;
337411781a2SMichael Ellerman 
338411781a2SMichael Ellerman 	return (unsigned long)imm;
339411781a2SMichael Ellerman }
340411781a2SMichael Ellerman 
34169d4d6e5SChristophe Leroy static unsigned long branch_bform_target(const u32 *instr)
342411781a2SMichael Ellerman {
343411781a2SMichael Ellerman 	signed long imm;
344411781a2SMichael Ellerman 
34518c85964SChristophe Leroy 	imm = ppc_inst_val(ppc_inst_read(instr)) & 0xFFFC;
346411781a2SMichael Ellerman 
347411781a2SMichael Ellerman 	/* If the top bit of the immediate value is set this is negative */
348411781a2SMichael Ellerman 	if (imm & 0x8000)
349411781a2SMichael Ellerman 		imm -= 0x10000;
350411781a2SMichael Ellerman 
35118c85964SChristophe Leroy 	if ((ppc_inst_val(ppc_inst_read(instr)) & BRANCH_ABSOLUTE) == 0)
352411781a2SMichael Ellerman 		imm += (unsigned long)instr;
353411781a2SMichael Ellerman 
354411781a2SMichael Ellerman 	return (unsigned long)imm;
355411781a2SMichael Ellerman }
356411781a2SMichael Ellerman 
35769d4d6e5SChristophe Leroy unsigned long branch_target(const u32 *instr)
358411781a2SMichael Ellerman {
359f8faaffaSJordan Niethe 	if (instr_is_branch_iform(ppc_inst_read(instr)))
360411781a2SMichael Ellerman 		return branch_iform_target(instr);
361f8faaffaSJordan Niethe 	else if (instr_is_branch_bform(ppc_inst_read(instr)))
362411781a2SMichael Ellerman 		return branch_bform_target(instr);
363411781a2SMichael Ellerman 
364411781a2SMichael Ellerman 	return 0;
365411781a2SMichael Ellerman }
366411781a2SMichael Ellerman 
36769d4d6e5SChristophe Leroy int translate_branch(struct ppc_inst *instr, const u32 *dest, const u32 *src)
368411781a2SMichael Ellerman {
369411781a2SMichael Ellerman 	unsigned long target;
370411781a2SMichael Ellerman 	target = branch_target(src);
371411781a2SMichael Ellerman 
372f8faaffaSJordan Niethe 	if (instr_is_branch_iform(ppc_inst_read(src)))
373f8faaffaSJordan Niethe 		return create_branch(instr, dest, target,
374f8faaffaSJordan Niethe 				     ppc_inst_val(ppc_inst_read(src)));
375f8faaffaSJordan Niethe 	else if (instr_is_branch_bform(ppc_inst_read(src)))
376f8faaffaSJordan Niethe 		return create_cond_branch(instr, dest, target,
377f8faaffaSJordan Niethe 					  ppc_inst_val(ppc_inst_read(src)));
378411781a2SMichael Ellerman 
3797c95d889SJordan Niethe 	return 1;
380411781a2SMichael Ellerman }
381ae0dc736SMichael Ellerman 
3821e8341aeSKevin Hao #ifdef CONFIG_PPC_BOOK3E_64
3831e8341aeSKevin Hao void __patch_exception(int exc, unsigned long addr)
3841e8341aeSKevin Hao {
3851e8341aeSKevin Hao 	extern unsigned int interrupt_base_book3e;
3861e8341aeSKevin Hao 	unsigned int *ibase = &interrupt_base_book3e;
3871e8341aeSKevin Hao 
3881e8341aeSKevin Hao 	/* Our exceptions vectors start with a NOP and -then- a branch
3891e8341aeSKevin Hao 	 * to deal with single stepping from userspace which stops on
3901e8341aeSKevin Hao 	 * the second instruction. Thus we need to patch the second
3911e8341aeSKevin Hao 	 * instruction of the exception, not the first one
3921e8341aeSKevin Hao 	 */
3931e8341aeSKevin Hao 
39469d4d6e5SChristophe Leroy 	patch_branch(ibase + (exc / 4) + 1, addr, 0);
3951e8341aeSKevin Hao }
3961e8341aeSKevin Hao #endif
397ae0dc736SMichael Ellerman 
398ae0dc736SMichael Ellerman #ifdef CONFIG_CODE_PATCHING_SELFTEST
399ae0dc736SMichael Ellerman 
40069d4d6e5SChristophe Leroy static int instr_is_branch_to_addr(const u32 *instr, unsigned long addr)
4016c0d181dSChristophe Leroy {
4026c0d181dSChristophe Leroy 	if (instr_is_branch_iform(ppc_inst_read(instr)) ||
4036c0d181dSChristophe Leroy 	    instr_is_branch_bform(ppc_inst_read(instr)))
4046c0d181dSChristophe Leroy 		return branch_target(instr) == addr;
4056c0d181dSChristophe Leroy 
4066c0d181dSChristophe Leroy 	return 0;
4076c0d181dSChristophe Leroy }
4086c0d181dSChristophe Leroy 
409ae0dc736SMichael Ellerman static void __init test_trampoline(void)
410ae0dc736SMichael Ellerman {
411ae0dc736SMichael Ellerman 	asm ("nop;\n");
412ae0dc736SMichael Ellerman }
413ae0dc736SMichael Ellerman 
414ae0dc736SMichael Ellerman #define check(x)	\
415ae0dc736SMichael Ellerman 	if (!(x)) printk("code-patching: test failed at line %d\n", __LINE__);
416ae0dc736SMichael Ellerman 
417ae0dc736SMichael Ellerman static void __init test_branch_iform(void)
418ae0dc736SMichael Ellerman {
4197c95d889SJordan Niethe 	int err;
42094afd069SJordan Niethe 	struct ppc_inst instr;
421e90a21eaSChristophe Leroy 	u32 tmp[2];
42269d4d6e5SChristophe Leroy 	u32 *iptr = tmp;
423e90a21eaSChristophe Leroy 	unsigned long addr = (unsigned long)tmp;
424ae0dc736SMichael Ellerman 
425ae0dc736SMichael Ellerman 	/* The simplest case, branch to self, no flags */
42675346251SJordan Niethe 	check(instr_is_branch_iform(ppc_inst(0x48000000)));
427ae0dc736SMichael Ellerman 	/* All bits of target set, and flags */
42875346251SJordan Niethe 	check(instr_is_branch_iform(ppc_inst(0x4bffffff)));
429ae0dc736SMichael Ellerman 	/* High bit of opcode set, which is wrong */
43075346251SJordan Niethe 	check(!instr_is_branch_iform(ppc_inst(0xcbffffff)));
431ae0dc736SMichael Ellerman 	/* Middle bits of opcode set, which is wrong */
43275346251SJordan Niethe 	check(!instr_is_branch_iform(ppc_inst(0x7bffffff)));
433ae0dc736SMichael Ellerman 
434ae0dc736SMichael Ellerman 	/* Simplest case, branch to self with link */
43575346251SJordan Niethe 	check(instr_is_branch_iform(ppc_inst(0x48000001)));
436ae0dc736SMichael Ellerman 	/* All bits of targets set */
43775346251SJordan Niethe 	check(instr_is_branch_iform(ppc_inst(0x4bfffffd)));
438ae0dc736SMichael Ellerman 	/* Some bits of targets set */
43975346251SJordan Niethe 	check(instr_is_branch_iform(ppc_inst(0x4bff00fd)));
440ae0dc736SMichael Ellerman 	/* Must be a valid branch to start with */
44175346251SJordan Niethe 	check(!instr_is_branch_iform(ppc_inst(0x7bfffffd)));
442ae0dc736SMichael Ellerman 
443ae0dc736SMichael Ellerman 	/* Absolute branch to 0x100 */
444e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x48000103));
445e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, 0x100));
446ae0dc736SMichael Ellerman 	/* Absolute branch to 0x420fc */
447e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x480420ff));
448e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, 0x420fc));
449ae0dc736SMichael Ellerman 	/* Maximum positive relative branch, + 20MB - 4B */
450e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x49fffffc));
451e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr + 0x1FFFFFC));
452ae0dc736SMichael Ellerman 	/* Smallest negative relative branch, - 4B */
453e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x4bfffffc));
454e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 4));
455ae0dc736SMichael Ellerman 	/* Largest negative relative branch, - 32 MB */
456e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x4a000000));
457e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 0x2000000));
458ae0dc736SMichael Ellerman 
459ae0dc736SMichael Ellerman 	/* Branch to self, with link */
460e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr, BRANCH_SET_LINK);
461e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
462e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr));
463ae0dc736SMichael Ellerman 
464ae0dc736SMichael Ellerman 	/* Branch to self - 0x100, with link */
465e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr - 0x100, BRANCH_SET_LINK);
466e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
467e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 0x100));
468ae0dc736SMichael Ellerman 
469ae0dc736SMichael Ellerman 	/* Branch to self + 0x100, no link */
470e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr + 0x100, 0);
471e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
472e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr + 0x100));
473ae0dc736SMichael Ellerman 
474ae0dc736SMichael Ellerman 	/* Maximum relative negative offset, - 32 MB */
475e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr - 0x2000000, BRANCH_SET_LINK);
476e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
477e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 0x2000000));
478ae0dc736SMichael Ellerman 
479ae0dc736SMichael Ellerman 	/* Out of range relative negative offset, - 32 MB + 4*/
480e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr - 0x2000004, BRANCH_SET_LINK);
4817c95d889SJordan Niethe 	check(err);
482ae0dc736SMichael Ellerman 
483ae0dc736SMichael Ellerman 	/* Out of range relative positive offset, + 32 MB */
484e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr + 0x2000000, BRANCH_SET_LINK);
4857c95d889SJordan Niethe 	check(err);
486ae0dc736SMichael Ellerman 
487ae0dc736SMichael Ellerman 	/* Unaligned target */
488e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr + 3, BRANCH_SET_LINK);
4897c95d889SJordan Niethe 	check(err);
490ae0dc736SMichael Ellerman 
491ae0dc736SMichael Ellerman 	/* Check flags are masked correctly */
492e90a21eaSChristophe Leroy 	err = create_branch(&instr, iptr, addr, 0xFFFFFFFC);
493e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
494e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr));
495217862d9SJordan Niethe 	check(ppc_inst_equal(instr, ppc_inst(0x48000000)));
496ae0dc736SMichael Ellerman }
497ae0dc736SMichael Ellerman 
498ae0dc736SMichael Ellerman static void __init test_create_function_call(void)
499ae0dc736SMichael Ellerman {
50069d4d6e5SChristophe Leroy 	u32 *iptr;
501ae0dc736SMichael Ellerman 	unsigned long dest;
50294afd069SJordan Niethe 	struct ppc_inst instr;
503ae0dc736SMichael Ellerman 
504ae0dc736SMichael Ellerman 	/* Check we can create a function call */
50569d4d6e5SChristophe Leroy 	iptr = (u32 *)ppc_function_entry(test_trampoline);
506ae0dc736SMichael Ellerman 	dest = ppc_function_entry(test_create_function_call);
5077c95d889SJordan Niethe 	create_branch(&instr, iptr, dest, BRANCH_SET_LINK);
5087c95d889SJordan Niethe 	patch_instruction(iptr, instr);
509ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(iptr, dest));
510ae0dc736SMichael Ellerman }
511ae0dc736SMichael Ellerman 
512ae0dc736SMichael Ellerman static void __init test_branch_bform(void)
513ae0dc736SMichael Ellerman {
5147c95d889SJordan Niethe 	int err;
515ae0dc736SMichael Ellerman 	unsigned long addr;
51669d4d6e5SChristophe Leroy 	struct ppc_inst instr;
517e90a21eaSChristophe Leroy 	u32 tmp[2];
51869d4d6e5SChristophe Leroy 	u32 *iptr = tmp;
51994afd069SJordan Niethe 	unsigned int flags;
520ae0dc736SMichael Ellerman 
521ae0dc736SMichael Ellerman 	addr = (unsigned long)iptr;
522ae0dc736SMichael Ellerman 
523ae0dc736SMichael Ellerman 	/* The simplest case, branch to self, no flags */
52475346251SJordan Niethe 	check(instr_is_branch_bform(ppc_inst(0x40000000)));
525ae0dc736SMichael Ellerman 	/* All bits of target set, and flags */
52675346251SJordan Niethe 	check(instr_is_branch_bform(ppc_inst(0x43ffffff)));
527ae0dc736SMichael Ellerman 	/* High bit of opcode set, which is wrong */
52875346251SJordan Niethe 	check(!instr_is_branch_bform(ppc_inst(0xc3ffffff)));
529ae0dc736SMichael Ellerman 	/* Middle bits of opcode set, which is wrong */
53075346251SJordan Niethe 	check(!instr_is_branch_bform(ppc_inst(0x7bffffff)));
531ae0dc736SMichael Ellerman 
532ae0dc736SMichael Ellerman 	/* Absolute conditional branch to 0x100 */
533e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x43ff0103));
534e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, 0x100));
535ae0dc736SMichael Ellerman 	/* Absolute conditional branch to 0x20fc */
536e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x43ff20ff));
537e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, 0x20fc));
538ae0dc736SMichael Ellerman 	/* Maximum positive relative conditional branch, + 32 KB - 4B */
539e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x43ff7ffc));
540e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr + 0x7FFC));
541ae0dc736SMichael Ellerman 	/* Smallest negative relative conditional branch, - 4B */
542e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x43fffffc));
543e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 4));
544ae0dc736SMichael Ellerman 	/* Largest negative relative conditional branch, - 32 KB */
545e90a21eaSChristophe Leroy 	patch_instruction(iptr, ppc_inst(0x43ff8000));
546e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 0x8000));
547ae0dc736SMichael Ellerman 
548ae0dc736SMichael Ellerman 	/* All condition code bits set & link */
549ae0dc736SMichael Ellerman 	flags = 0x3ff000 | BRANCH_SET_LINK;
550ae0dc736SMichael Ellerman 
551ae0dc736SMichael Ellerman 	/* Branch to self */
5527c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr, flags);
553e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
554e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr));
555ae0dc736SMichael Ellerman 
556ae0dc736SMichael Ellerman 	/* Branch to self - 0x100 */
5577c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr - 0x100, flags);
558e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
559e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 0x100));
560ae0dc736SMichael Ellerman 
561ae0dc736SMichael Ellerman 	/* Branch to self + 0x100 */
5627c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr + 0x100, flags);
563e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
564e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr + 0x100));
565ae0dc736SMichael Ellerman 
566ae0dc736SMichael Ellerman 	/* Maximum relative negative offset, - 32 KB */
5677c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr - 0x8000, flags);
568e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
569e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr - 0x8000));
570ae0dc736SMichael Ellerman 
571ae0dc736SMichael Ellerman 	/* Out of range relative negative offset, - 32 KB + 4*/
5727c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr - 0x8004, flags);
5737c95d889SJordan Niethe 	check(err);
574ae0dc736SMichael Ellerman 
575ae0dc736SMichael Ellerman 	/* Out of range relative positive offset, + 32 KB */
5767c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr + 0x8000, flags);
5777c95d889SJordan Niethe 	check(err);
578ae0dc736SMichael Ellerman 
579ae0dc736SMichael Ellerman 	/* Unaligned target */
5807c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr + 3, flags);
5817c95d889SJordan Niethe 	check(err);
582ae0dc736SMichael Ellerman 
583ae0dc736SMichael Ellerman 	/* Check flags are masked correctly */
5847c95d889SJordan Niethe 	err = create_cond_branch(&instr, iptr, addr, 0xFFFFFFFC);
585e90a21eaSChristophe Leroy 	patch_instruction(iptr, instr);
586e90a21eaSChristophe Leroy 	check(instr_is_branch_to_addr(iptr, addr));
587217862d9SJordan Niethe 	check(ppc_inst_equal(instr, ppc_inst(0x43FF0000)));
588ae0dc736SMichael Ellerman }
589ae0dc736SMichael Ellerman 
590ae0dc736SMichael Ellerman static void __init test_translate_branch(void)
591ae0dc736SMichael Ellerman {
592ae0dc736SMichael Ellerman 	unsigned long addr;
5930b582db5SJordan Niethe 	void *p, *q;
59494afd069SJordan Niethe 	struct ppc_inst instr;
595ae0dc736SMichael Ellerman 	void *buf;
596ae0dc736SMichael Ellerman 
597ae0dc736SMichael Ellerman 	buf = vmalloc(PAGE_ALIGN(0x2000000 + 1));
598ae0dc736SMichael Ellerman 	check(buf);
599ae0dc736SMichael Ellerman 	if (!buf)
600ae0dc736SMichael Ellerman 		return;
601ae0dc736SMichael Ellerman 
602ae0dc736SMichael Ellerman 	/* Simple case, branch to self moved a little */
603ae0dc736SMichael Ellerman 	p = buf;
604ae0dc736SMichael Ellerman 	addr = (unsigned long)p;
605ae0dc736SMichael Ellerman 	patch_branch(p, addr, 0);
606ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
6070b582db5SJordan Niethe 	q = p + 4;
6087c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6097c95d889SJordan Niethe 	patch_instruction(q, instr);
610ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
611ae0dc736SMichael Ellerman 
612ae0dc736SMichael Ellerman 	/* Maximum negative case, move b . to addr + 32 MB */
613ae0dc736SMichael Ellerman 	p = buf;
614ae0dc736SMichael Ellerman 	addr = (unsigned long)p;
615ae0dc736SMichael Ellerman 	patch_branch(p, addr, 0);
616ae0dc736SMichael Ellerman 	q = buf + 0x2000000;
6177c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6187c95d889SJordan Niethe 	patch_instruction(q, instr);
619ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
620ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
621f8faaffaSJordan Niethe 	check(ppc_inst_equal(ppc_inst_read(q), ppc_inst(0x4a000000)));
622ae0dc736SMichael Ellerman 
623ae0dc736SMichael Ellerman 	/* Maximum positive case, move x to x - 32 MB + 4 */
624ae0dc736SMichael Ellerman 	p = buf + 0x2000000;
625ae0dc736SMichael Ellerman 	addr = (unsigned long)p;
626ae0dc736SMichael Ellerman 	patch_branch(p, addr, 0);
627ae0dc736SMichael Ellerman 	q = buf + 4;
6287c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6297c95d889SJordan Niethe 	patch_instruction(q, instr);
630ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
631ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
632f8faaffaSJordan Niethe 	check(ppc_inst_equal(ppc_inst_read(q), ppc_inst(0x49fffffc)));
633ae0dc736SMichael Ellerman 
634ae0dc736SMichael Ellerman 	/* Jump to x + 16 MB moved to x + 20 MB */
635ae0dc736SMichael Ellerman 	p = buf;
636ae0dc736SMichael Ellerman 	addr = 0x1000000 + (unsigned long)buf;
637ae0dc736SMichael Ellerman 	patch_branch(p, addr, BRANCH_SET_LINK);
638ae0dc736SMichael Ellerman 	q = buf + 0x1400000;
6397c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6407c95d889SJordan Niethe 	patch_instruction(q, instr);
641ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
642ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
643ae0dc736SMichael Ellerman 
644ae0dc736SMichael Ellerman 	/* Jump to x + 16 MB moved to x - 16 MB + 4 */
645ae0dc736SMichael Ellerman 	p = buf + 0x1000000;
646ae0dc736SMichael Ellerman 	addr = 0x2000000 + (unsigned long)buf;
647ae0dc736SMichael Ellerman 	patch_branch(p, addr, 0);
648ae0dc736SMichael Ellerman 	q = buf + 4;
6497c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6507c95d889SJordan Niethe 	patch_instruction(q, instr);
651ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
652ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
653ae0dc736SMichael Ellerman 
654ae0dc736SMichael Ellerman 
655ae0dc736SMichael Ellerman 	/* Conditional branch tests */
656ae0dc736SMichael Ellerman 
657ae0dc736SMichael Ellerman 	/* Simple case, branch to self moved a little */
658ae0dc736SMichael Ellerman 	p = buf;
659ae0dc736SMichael Ellerman 	addr = (unsigned long)p;
6607c95d889SJordan Niethe 	create_cond_branch(&instr, p, addr, 0);
6617c95d889SJordan Niethe 	patch_instruction(p, instr);
662ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
6630b582db5SJordan Niethe 	q = buf + 4;
6647c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6657c95d889SJordan Niethe 	patch_instruction(q, instr);
666ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
667ae0dc736SMichael Ellerman 
668ae0dc736SMichael Ellerman 	/* Maximum negative case, move b . to addr + 32 KB */
669ae0dc736SMichael Ellerman 	p = buf;
670ae0dc736SMichael Ellerman 	addr = (unsigned long)p;
6717c95d889SJordan Niethe 	create_cond_branch(&instr, p, addr, 0xFFFFFFFC);
6727c95d889SJordan Niethe 	patch_instruction(p, instr);
673ae0dc736SMichael Ellerman 	q = buf + 0x8000;
6747c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6757c95d889SJordan Niethe 	patch_instruction(q, instr);
676ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
677ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
678f8faaffaSJordan Niethe 	check(ppc_inst_equal(ppc_inst_read(q), ppc_inst(0x43ff8000)));
679ae0dc736SMichael Ellerman 
680ae0dc736SMichael Ellerman 	/* Maximum positive case, move x to x - 32 KB + 4 */
681ae0dc736SMichael Ellerman 	p = buf + 0x8000;
682ae0dc736SMichael Ellerman 	addr = (unsigned long)p;
6837c95d889SJordan Niethe 	create_cond_branch(&instr, p, addr, 0xFFFFFFFC);
6847c95d889SJordan Niethe 	patch_instruction(p, instr);
685ae0dc736SMichael Ellerman 	q = buf + 4;
6867c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6877c95d889SJordan Niethe 	patch_instruction(q, instr);
688ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
689ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
690f8faaffaSJordan Niethe 	check(ppc_inst_equal(ppc_inst_read(q), ppc_inst(0x43ff7ffc)));
691ae0dc736SMichael Ellerman 
692ae0dc736SMichael Ellerman 	/* Jump to x + 12 KB moved to x + 20 KB */
693ae0dc736SMichael Ellerman 	p = buf;
694ae0dc736SMichael Ellerman 	addr = 0x3000 + (unsigned long)buf;
6957c95d889SJordan Niethe 	create_cond_branch(&instr, p, addr, BRANCH_SET_LINK);
6967c95d889SJordan Niethe 	patch_instruction(p, instr);
697ae0dc736SMichael Ellerman 	q = buf + 0x5000;
6987c95d889SJordan Niethe 	translate_branch(&instr, q, p);
6997c95d889SJordan Niethe 	patch_instruction(q, instr);
700ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
701ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
702ae0dc736SMichael Ellerman 
703ae0dc736SMichael Ellerman 	/* Jump to x + 8 KB moved to x - 8 KB + 4 */
704ae0dc736SMichael Ellerman 	p = buf + 0x2000;
705ae0dc736SMichael Ellerman 	addr = 0x4000 + (unsigned long)buf;
7067c95d889SJordan Niethe 	create_cond_branch(&instr, p, addr, 0);
7077c95d889SJordan Niethe 	patch_instruction(p, instr);
708ae0dc736SMichael Ellerman 	q = buf + 4;
7097c95d889SJordan Niethe 	translate_branch(&instr, q, p);
7107c95d889SJordan Niethe 	patch_instruction(q, instr);
711ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(p, addr));
712ae0dc736SMichael Ellerman 	check(instr_is_branch_to_addr(q, addr));
713ae0dc736SMichael Ellerman 
714ae0dc736SMichael Ellerman 	/* Free the buffer we were using */
715ae0dc736SMichael Ellerman 	vfree(buf);
716ae0dc736SMichael Ellerman }
717ae0dc736SMichael Ellerman 
718f77f8ff7SJordan Niethe #ifdef CONFIG_PPC64
719f77f8ff7SJordan Niethe static void __init test_prefixed_patching(void)
720f77f8ff7SJordan Niethe {
721f77f8ff7SJordan Niethe 	extern unsigned int code_patching_test1[];
722f77f8ff7SJordan Niethe 	extern unsigned int code_patching_test1_expected[];
723f77f8ff7SJordan Niethe 	extern unsigned int end_code_patching_test1[];
724f77f8ff7SJordan Niethe 
72569d4d6e5SChristophe Leroy 	__patch_instruction(code_patching_test1,
726f77f8ff7SJordan Niethe 			    ppc_inst_prefix(OP_PREFIX << 26, 0x00000000),
72769d4d6e5SChristophe Leroy 			    code_patching_test1);
728f77f8ff7SJordan Niethe 
729f77f8ff7SJordan Niethe 	check(!memcmp(code_patching_test1,
730f77f8ff7SJordan Niethe 		      code_patching_test1_expected,
731f77f8ff7SJordan Niethe 		      sizeof(unsigned int) *
732f77f8ff7SJordan Niethe 		      (end_code_patching_test1 - code_patching_test1)));
733f77f8ff7SJordan Niethe }
734f77f8ff7SJordan Niethe #else
735f77f8ff7SJordan Niethe static inline void test_prefixed_patching(void) {}
736f77f8ff7SJordan Niethe #endif
737f77f8ff7SJordan Niethe 
738ae0dc736SMichael Ellerman static int __init test_code_patching(void)
739ae0dc736SMichael Ellerman {
740ae0dc736SMichael Ellerman 	printk(KERN_DEBUG "Running code patching self-tests ...\n");
741ae0dc736SMichael Ellerman 
742ae0dc736SMichael Ellerman 	test_branch_iform();
743ae0dc736SMichael Ellerman 	test_branch_bform();
744ae0dc736SMichael Ellerman 	test_create_function_call();
745ae0dc736SMichael Ellerman 	test_translate_branch();
746f77f8ff7SJordan Niethe 	test_prefixed_patching();
747ae0dc736SMichael Ellerman 
748ae0dc736SMichael Ellerman 	return 0;
749ae0dc736SMichael Ellerman }
750ae0dc736SMichael Ellerman late_initcall(test_code_patching);
751ae0dc736SMichael Ellerman 
752ae0dc736SMichael Ellerman #endif /* CONFIG_CODE_PATCHING_SELFTEST */
753