arch/powerpc/kernel/entry_32.S

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  *  PowerPC version
   4  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
   5  *  Rewritten by Cort Dougan (cort@fsmlabs.com) for PReP
   6  *    Copyright (C) 1996 Cort Dougan <cort@fsmlabs.com>
   7  *  Adapted for Power Macintosh by Paul Mackerras.
   8  *  Low-level exception handlers and MMU support
   9  *  rewritten by Paul Mackerras.
  10  *    Copyright (C) 1996 Paul Mackerras.
  11  *  MPC8xx modifications Copyright (C) 1997 Dan Malek (dmalek@jlc.net).
  12  *
  13  *  This file contains the system call entry code, context switch
  14  *  code, and exception/interrupt return code for PowerPC.
  15  */
  16
  17 #include <linux/errno.h>
  18 #include <linux/err.h>
  19 #include <linux/sys.h>
  20 #include <linux/threads.h>
  21 #include <linux/linkage.h>
  22
  23 #include <asm/reg.h>
  24 #include <asm/page.h>
  25 #include <asm/mmu.h>
  26 #include <asm/cputable.h>
  27 #include <asm/thread_info.h>
  28 #include <asm/ppc_asm.h>
  29 #include <asm/asm-offsets.h>
  30 #include <asm/unistd.h>
  31 #include <asm/ptrace.h>
  32 #include <asm/export.h>
  33 #include <asm/feature-fixups.h>
  34 #include <asm/barrier.h>
  35 #include <asm/kup.h>
  36 #include <asm/bug.h>
  37 #include <asm/interrupt.h>
  38
  39 #include "head_32.h"
  40
  41 /*
  42  * powerpc relies on return from interrupt/syscall being context synchronising
  43  * (which rfi is) to support ARCH_HAS_MEMBARRIER_SYNC_CORE without additional
  44  * synchronisation instructions.
  45  */
  46
  47 /*
  48  * Align to 4k in order to ensure that all functions modyfing srr0/srr1
  49  * fit into one page in order to not encounter a TLB miss between the
  50  * modification of srr0/srr1 and the associated rfi.
  51  */
  52         .align  12
  53
  54 #if defined(CONFIG_PPC_BOOK3S_32) || defined(CONFIG_PPC_E500)
  55         .globl  prepare_transfer_to_handler
  56 prepare_transfer_to_handler:
  57         /* if from kernel, check interrupted DOZE/NAP mode */
  58         lwz     r12,TI_LOCAL_FLAGS(r2)
  59         mtcrf   0x01,r12
  60         bt-     31-TLF_NAPPING,4f
  61         bt-     31-TLF_SLEEPING,7f
  62         blr
  63
  64 4:      rlwinm  r12,r12,0,~_TLF_NAPPING
  65         stw     r12,TI_LOCAL_FLAGS(r2)
  66         b       power_save_ppc32_restore
  67
  68 7:      rlwinm  r12,r12,0,~_TLF_SLEEPING
  69         stw     r12,TI_LOCAL_FLAGS(r2)
  70         lwz     r9,_MSR(r11)            /* if sleeping, clear MSR.EE */
  71         rlwinm  r9,r9,0,~MSR_EE
  72         lwz     r12,_LINK(r11)          /* and return to address in LR */
  73         REST_GPR(2, r11)
  74         b       fast_exception_return
  75 _ASM_NOKPROBE_SYMBOL(prepare_transfer_to_handler)
  76 #endif /* CONFIG_PPC_BOOK3S_32 || CONFIG_PPC_E500 */
  77
  78 #if defined(CONFIG_PPC_KUEP) && defined(CONFIG_PPC_BOOK3S_32)
  79 SYM_FUNC_START(__kuep_lock)
  80         lwz     r9, THREAD+THSR0(r2)
  81         update_user_segments_by_4 r9, r10, r11, r12
  82         blr
  83 SYM_FUNC_END(__kuep_lock)
  84
  85 SYM_FUNC_START_LOCAL(__kuep_unlock)
  86         lwz     r9, THREAD+THSR0(r2)
  87         rlwinm  r9,r9,0,~SR_NX
  88         update_user_segments_by_4 r9, r10, r11, r12
  89         blr
  90 SYM_FUNC_END(__kuep_unlock)
  91
  92 .macro  kuep_lock
  93         bl      __kuep_lock
  94 .endm
  95 .macro  kuep_unlock
  96         bl      __kuep_unlock
  97 .endm
  98 #else
  99 .macro  kuep_lock
 100 .endm
 101 .macro  kuep_unlock
 102 .endm
 103 #endif
 104
 105         .globl  transfer_to_syscall
 106 transfer_to_syscall:
 107         stw     r3, ORIG_GPR3(r1)
 108         stw     r11, GPR1(r1)
 109         stw     r11, 0(r1)
 110         mflr    r12
 111         stw     r12, _LINK(r1)
 112 #ifdef CONFIG_BOOKE_OR_40x
 113         rlwinm  r9,r9,0,14,12           /* clear MSR_WE (necessary?) */
 114 #endif
 115         lis     r12,STACK_FRAME_REGS_MARKER@ha /* exception frame marker */
 116         SAVE_GPR(2, r1)
 117         addi    r12,r12,STACK_FRAME_REGS_MARKER@l
 118         stw     r9,_MSR(r1)
 119         li      r2, INTERRUPT_SYSCALL
 120         stw     r12,STACK_INT_FRAME_MARKER(r1)
 121         stw     r2,_TRAP(r1)
 122         SAVE_GPR(0, r1)
 123         SAVE_GPRS(3, 8, r1)
 124         addi    r2,r10,-THREAD
 125         SAVE_NVGPRS(r1)
 126         kuep_lock
 127
 128         /* Calling convention has r3 = regs, r4 = orig r0 */
 129         addi    r3,r1,STACK_INT_FRAME_REGS
 130         mr      r4,r0
 131         bl      system_call_exception
 132
 133 ret_from_syscall:
 134         addi    r4,r1,STACK_INT_FRAME_REGS
 135         li      r5,0
 136         bl      syscall_exit_prepare
 137 #ifdef CONFIG_PPC_47x
 138         lis     r4,icache_44x_need_flush@ha
 139         lwz     r5,icache_44x_need_flush@l(r4)
 140         cmplwi  cr0,r5,0
 141         bne-    .L44x_icache_flush
 142 #endif /* CONFIG_PPC_47x */
 143 .L44x_icache_flush_return:
 144         kuep_unlock
 145         lwz     r4,_LINK(r1)
 146         lwz     r5,_CCR(r1)
 147         mtlr    r4
 148         lwz     r7,_NIP(r1)
 149         lwz     r8,_MSR(r1)
 150         cmpwi   r3,0
 151         REST_GPR(3, r1)
 152 syscall_exit_finish:
 153         mtspr   SPRN_SRR0,r7
 154         mtspr   SPRN_SRR1,r8
 155
 156         bne     3f
 157         mtcr    r5
 158
 159 1:      REST_GPR(2, r1)
 160         REST_GPR(1, r1)
 161         rfi
 162 #ifdef CONFIG_40x
 163         b .     /* Prevent prefetch past rfi */
 164 #endif
 165
 166 3:      mtcr    r5
 167         lwz     r4,_CTR(r1)
 168         lwz     r5,_XER(r1)
 169         REST_NVGPRS(r1)
 170         mtctr   r4
 171         mtxer   r5
 172         REST_GPR(0, r1)
 173         REST_GPRS(3, 12, r1)
 174         b       1b
 175
 176 #ifdef CONFIG_44x
 177 .L44x_icache_flush:
 178         li      r7,0
 179         iccci   r0,r0
 180         stw     r7,icache_44x_need_flush@l(r4)
 181         b       .L44x_icache_flush_return
 182 #endif  /* CONFIG_44x */
 183
 184         .globl  ret_from_fork
 185 ret_from_fork:
 186         REST_NVGPRS(r1)
 187         bl      schedule_tail
 188         li      r3,0    /* fork() return value */
 189         b       ret_from_syscall
 190
 191         .globl  ret_from_kernel_user_thread
 192 ret_from_kernel_user_thread:
 193         bl      schedule_tail
 194         mtctr   r14
 195         mr      r3,r15
 196         PPC440EP_ERR42
 197         bctrl
 198         li      r3,0
 199         b       ret_from_syscall
 200
 201         .globl  start_kernel_thread
 202 start_kernel_thread:
 203         bl      schedule_tail
 204         mtctr   r14
 205         mr      r3,r15
 206         PPC440EP_ERR42
 207         bctrl
 208         /*
 209          * This must not return. We actually want to BUG here, not WARN,
 210          * because BUG will exit the process which is what the kernel thread
 211          * should have done, which may give some hope of continuing.
 212          */
 213 100:    trap
 214         EMIT_BUG_ENTRY 100b,__FILE__,__LINE__,0
 215
 216         .globl  fast_exception_return
 217 fast_exception_return:
 218 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
 219         andi.   r10,r9,MSR_RI           /* check for recoverable interrupt */
 220         beq     3f                      /* if not, we've got problems */
 221 #endif
 222
 223 2:      lwz     r10,_CCR(r11)
 224         REST_GPRS(1, 6, r11)
 225         mtcr    r10
 226         lwz     r10,_LINK(r11)
 227         mtlr    r10
 228         /* Clear the exception marker on the stack to avoid confusing stacktrace */
 229         li      r10, 0
 230         stw     r10, 8(r11)
 231         REST_GPR(10, r11)
 232 #if defined(CONFIG_PPC_8xx) && defined(CONFIG_PERF_EVENTS)
 233         mtspr   SPRN_NRI, r0
 234 #endif
 235         mtspr   SPRN_SRR1,r9
 236         mtspr   SPRN_SRR0,r12
 237         REST_GPR(9, r11)
 238         REST_GPR(12, r11)
 239         REST_GPR(11, r11)
 240         rfi
 241 #ifdef CONFIG_40x
 242         b .     /* Prevent prefetch past rfi */
 243 #endif
 244 _ASM_NOKPROBE_SYMBOL(fast_exception_return)
 245
 246 /* aargh, a nonrecoverable interrupt, panic */
 247 /* aargh, we don't know which trap this is */
 248 3:
 249         li      r10,-1
 250         stw     r10,_TRAP(r11)
 251         prepare_transfer_to_handler
 252         bl      unrecoverable_exception
 253         trap    /* should not get here */
 254
 255         .globl interrupt_return
 256 interrupt_return:
 257         lwz     r4,_MSR(r1)
 258         addi    r3,r1,STACK_INT_FRAME_REGS
 259         andi.   r0,r4,MSR_PR
 260         beq     .Lkernel_interrupt_return
 261         bl      interrupt_exit_user_prepare
 262         cmpwi   r3,0
 263         kuep_unlock
 264         bne-    .Lrestore_nvgprs
 265
 266 .Lfast_user_interrupt_return:
 267         lwz     r11,_NIP(r1)
 268         lwz     r12,_MSR(r1)
 269         mtspr   SPRN_SRR0,r11
 270         mtspr   SPRN_SRR1,r12
 271
 272 BEGIN_FTR_SECTION
 273         stwcx.  r0,0,r1         /* to clear the reservation */
 274 FTR_SECTION_ELSE
 275         lwarx   r0,0,r1
 276 ALT_FTR_SECTION_END_IFCLR(CPU_FTR_STCX_CHECKS_ADDRESS)
 277
 278         lwz     r3,_CCR(r1)
 279         lwz     r4,_LINK(r1)
 280         lwz     r5,_CTR(r1)
 281         lwz     r6,_XER(r1)
 282         li      r0,0
 283
 284         /*
 285          * Leaving a stale exception marker on the stack can confuse
 286          * the reliable stack unwinder later on. Clear it.
 287          */
 288         stw     r0,8(r1)
 289         REST_GPRS(7, 12, r1)
 290
 291         mtcr    r3
 292         mtlr    r4
 293         mtctr   r5
 294         mtspr   SPRN_XER,r6
 295
 296         REST_GPRS(2, 6, r1)
 297         REST_GPR(0, r1)
 298         REST_GPR(1, r1)
 299         rfi
 300 #ifdef CONFIG_40x
 301         b .     /* Prevent prefetch past rfi */
 302 #endif
 303
 304 .Lrestore_nvgprs:
 305         REST_NVGPRS(r1)
 306         b       .Lfast_user_interrupt_return
 307
 308 .Lkernel_interrupt_return:
 309         bl      interrupt_exit_kernel_prepare
 310
 311 .Lfast_kernel_interrupt_return:
 312         cmpwi   cr1,r3,0
 313         lwz     r11,_NIP(r1)
 314         lwz     r12,_MSR(r1)
 315         mtspr   SPRN_SRR0,r11
 316         mtspr   SPRN_SRR1,r12
 317
 318 BEGIN_FTR_SECTION
 319         stwcx.  r0,0,r1         /* to clear the reservation */
 320 FTR_SECTION_ELSE
 321         lwarx   r0,0,r1
 322 ALT_FTR_SECTION_END_IFCLR(CPU_FTR_STCX_CHECKS_ADDRESS)
 323
 324         lwz     r3,_LINK(r1)
 325         lwz     r4,_CTR(r1)
 326         lwz     r5,_XER(r1)
 327         lwz     r6,_CCR(r1)
 328         li      r0,0
 329
 330         REST_GPRS(7, 12, r1)
 331
 332         mtlr    r3
 333         mtctr   r4
 334         mtspr   SPRN_XER,r5
 335
 336         /*
 337          * Leaving a stale exception marker on the stack can confuse
 338          * the reliable stack unwinder later on. Clear it.
 339          */
 340         stw     r0,8(r1)
 341
 342         REST_GPRS(2, 5, r1)
 343
 344         bne-    cr1,1f /* emulate stack store */
 345         mtcr    r6
 346         REST_GPR(6, r1)
 347         REST_GPR(0, r1)
 348         REST_GPR(1, r1)
 349         rfi
 350 #ifdef CONFIG_40x
 351         b .     /* Prevent prefetch past rfi */
 352 #endif
 353
 354 1:      /*
 355          * Emulate stack store with update. New r1 value was already calculated
 356          * and updated in our interrupt regs by emulate_loadstore, but we can't
 357          * store the previous value of r1 to the stack before re-loading our
 358          * registers from it, otherwise they could be clobbered.  Use
 359          * SPRG Scratch0 as temporary storage to hold the store
 360          * data, as interrupts are disabled here so it won't be clobbered.
 361          */
 362         mtcr    r6
 363 #ifdef CONFIG_BOOKE
 364         mtspr   SPRN_SPRG_WSCRATCH0, r9
 365 #else
 366         mtspr   SPRN_SPRG_SCRATCH0, r9
 367 #endif
 368         addi    r9,r1,INT_FRAME_SIZE /* get original r1 */
 369         REST_GPR(6, r1)
 370         REST_GPR(0, r1)
 371         REST_GPR(1, r1)
 372         stw     r9,0(r1) /* perform store component of stwu */
 373 #ifdef CONFIG_BOOKE
 374         mfspr   r9, SPRN_SPRG_RSCRATCH0
 375 #else
 376         mfspr   r9, SPRN_SPRG_SCRATCH0
 377 #endif
 378         rfi
 379 #ifdef CONFIG_40x
 380         b .     /* Prevent prefetch past rfi */
 381 #endif
 382 _ASM_NOKPROBE_SYMBOL(interrupt_return)
 383
 384 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 385
 386 /*
 387  * Returning from a critical interrupt in user mode doesn't need
 388  * to be any different from a normal exception.  For a critical
 389  * interrupt in the kernel, we just return (without checking for
 390  * preemption) since the interrupt may have happened at some crucial
 391  * place (e.g. inside the TLB miss handler), and because we will be
 392  * running with r1 pointing into critical_stack, not the current
 393  * process's kernel stack (and therefore current_thread_info() will
 394  * give the wrong answer).
 395  * We have to restore various SPRs that may have been in use at the
 396  * time of the critical interrupt.
 397  *
 398  */
 399 #ifdef CONFIG_40x
 400 #define PPC_40x_TURN_OFF_MSR_DR                                             \
 401         /* avoid any possible TLB misses here by turning off MSR.DR, we     \
 402          * assume the instructions here are mapped by a pinned TLB entry */ \
 403         li      r10,MSR_IR;                                                 \
 404         mtmsr   r10;                                                        \
 405         isync;                                                              \
 406         tophys(r1, r1);
 407 #else
 408 #define PPC_40x_TURN_OFF_MSR_DR
 409 #endif
 410
 411 #define RET_FROM_EXC_LEVEL(exc_lvl_srr0, exc_lvl_srr1, exc_lvl_rfi)     \
 412         REST_NVGPRS(r1);                                                \
 413         lwz     r3,_MSR(r1);                                            \
 414         andi.   r3,r3,MSR_PR;                                           \
 415         bne     interrupt_return;                                       \
 416         REST_GPR(0, r1);                                                \
 417         REST_GPRS(2, 8, r1);                                            \
 418         lwz     r10,_XER(r1);                                           \
 419         lwz     r11,_CTR(r1);                                           \
 420         mtspr   SPRN_XER,r10;                                           \
 421         mtctr   r11;                                                    \
 422         stwcx.  r0,0,r1;                /* to clear the reservation */  \
 423         lwz     r11,_LINK(r1);                                          \
 424         mtlr    r11;                                                    \
 425         lwz     r10,_CCR(r1);                                           \
 426         mtcrf   0xff,r10;                                               \
 427         PPC_40x_TURN_OFF_MSR_DR;                                        \
 428         lwz     r9,_DEAR(r1);                                           \
 429         lwz     r10,_ESR(r1);                                           \
 430         mtspr   SPRN_DEAR,r9;                                           \
 431         mtspr   SPRN_ESR,r10;                                           \
 432         lwz     r11,_NIP(r1);                                           \
 433         lwz     r12,_MSR(r1);                                           \
 434         mtspr   exc_lvl_srr0,r11;                                       \
 435         mtspr   exc_lvl_srr1,r12;                                       \
 436         REST_GPRS(9, 12, r1);                                           \
 437         REST_GPR(1, r1);                                                \
 438         exc_lvl_rfi;                                                    \
 439         b       .;              /* prevent prefetch past exc_lvl_rfi */
 440
 441 #define RESTORE_xSRR(exc_lvl_srr0, exc_lvl_srr1)                        \
 442         lwz     r9,_##exc_lvl_srr0(r1);                                 \
 443         lwz     r10,_##exc_lvl_srr1(r1);                                \
 444         mtspr   SPRN_##exc_lvl_srr0,r9;                                 \
 445         mtspr   SPRN_##exc_lvl_srr1,r10;
 446
 447 #if defined(CONFIG_PPC_E500)
 448 #ifdef CONFIG_PHYS_64BIT
 449 #define RESTORE_MAS7                                                    \
 450         lwz     r11,MAS7(r1);                                           \
 451         mtspr   SPRN_MAS7,r11;
 452 #else
 453 #define RESTORE_MAS7
 454 #endif /* CONFIG_PHYS_64BIT */
 455 #define RESTORE_MMU_REGS                                                \
 456         lwz     r9,MAS0(r1);                                            \
 457         lwz     r10,MAS1(r1);                                           \
 458         lwz     r11,MAS2(r1);                                           \
 459         mtspr   SPRN_MAS0,r9;                                           \
 460         lwz     r9,MAS3(r1);                                            \
 461         mtspr   SPRN_MAS1,r10;                                          \
 462         lwz     r10,MAS6(r1);                                           \
 463         mtspr   SPRN_MAS2,r11;                                          \
 464         mtspr   SPRN_MAS3,r9;                                           \
 465         mtspr   SPRN_MAS6,r10;                                          \
 466         RESTORE_MAS7;
 467 #elif defined(CONFIG_44x)
 468 #define RESTORE_MMU_REGS                                                \
 469         lwz     r9,MMUCR(r1);                                           \
 470         mtspr   SPRN_MMUCR,r9;
 471 #else
 472 #define RESTORE_MMU_REGS
 473 #endif
 474
 475 #ifdef CONFIG_40x
 476         .globl  ret_from_crit_exc
 477 ret_from_crit_exc:
 478         lis     r9,crit_srr0@ha;
 479         lwz     r9,crit_srr0@l(r9);
 480         lis     r10,crit_srr1@ha;
 481         lwz     r10,crit_srr1@l(r10);
 482         mtspr   SPRN_SRR0,r9;
 483         mtspr   SPRN_SRR1,r10;
 484         RET_FROM_EXC_LEVEL(SPRN_CSRR0, SPRN_CSRR1, PPC_RFCI)
 485 _ASM_NOKPROBE_SYMBOL(ret_from_crit_exc)
 486 #endif /* CONFIG_40x */
 487
 488 #ifdef CONFIG_BOOKE
 489         .globl  ret_from_crit_exc
 490 ret_from_crit_exc:
 491         RESTORE_xSRR(SRR0,SRR1);
 492         RESTORE_MMU_REGS;
 493         RET_FROM_EXC_LEVEL(SPRN_CSRR0, SPRN_CSRR1, PPC_RFCI)
 494 _ASM_NOKPROBE_SYMBOL(ret_from_crit_exc)
 495
 496         .globl  ret_from_debug_exc
 497 ret_from_debug_exc:
 498         RESTORE_xSRR(SRR0,SRR1);
 499         RESTORE_xSRR(CSRR0,CSRR1);
 500         RESTORE_MMU_REGS;
 501         RET_FROM_EXC_LEVEL(SPRN_DSRR0, SPRN_DSRR1, PPC_RFDI)
 502 _ASM_NOKPROBE_SYMBOL(ret_from_debug_exc)
 503
 504         .globl  ret_from_mcheck_exc
 505 ret_from_mcheck_exc:
 506         RESTORE_xSRR(SRR0,SRR1);
 507         RESTORE_xSRR(CSRR0,CSRR1);
 508         RESTORE_xSRR(DSRR0,DSRR1);
 509         RESTORE_MMU_REGS;
 510         RET_FROM_EXC_LEVEL(SPRN_MCSRR0, SPRN_MCSRR1, PPC_RFMCI)
 511 _ASM_NOKPROBE_SYMBOL(ret_from_mcheck_exc)
 512 #endif /* CONFIG_BOOKE */
 513 #endif /* !(CONFIG_4xx || CONFIG_BOOKE) */