tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

arm64: entry: Consistently prefix arm64-specific wrappers

For historical reasons, arm64's entry code has arm64-specific functions
named enter_from_kernel_mode() and exit_to_kernel_mode(), which are
wrappers for similarly-named functions from the generic irqentry code.
Other arm64-specific wrappers have an 'arm64_' prefix to clearly
distinguish them from their generic counterparts, e.g.
arm64_enter_from_user_mode() and arm64_exit_to_user_mode().

For consistency and clarity, add an 'arm64_' prefix to these functions.

There should be no functional change as a result of this patch.

Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Jinjie Ruan <ruanjinjie@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@kernel.org>
Cc: Vladimir Murzin <vladimir.murzin@arm.com>
Cc: Will Deacon <will@kernel.org>
Reviewed-by: Jinjie Ruan <ruanjinjie@huawei.com>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>

authored by

Mark Rutland and committed by
Catalin Marinas 6879ef13 2371bd83

+19 -19
+19 -19
arch/arm64/kernel/entry-common.c
··· 35 35 * Before this function is called it is not safe to call regular kernel code, 36 36 * instrumentable code, or any code which may trigger an exception. 37 37 */ 38 - static noinstr irqentry_state_t enter_from_kernel_mode(struct pt_regs *regs) 38 + static noinstr irqentry_state_t arm64_enter_from_kernel_mode(struct pt_regs *regs) 39 39 { 40 40 irqentry_state_t state; 41 41 ··· 51 51 * After this function returns it is not safe to call regular kernel code, 52 52 * instrumentable code, or any code which may trigger an exception. 53 53 */ 54 - static void noinstr exit_to_kernel_mode(struct pt_regs *regs, 55 - irqentry_state_t state) 54 + static void noinstr arm64_exit_to_kernel_mode(struct pt_regs *regs, 55 + irqentry_state_t state) 56 56 { 57 57 mte_check_tfsr_exit(); 58 58 irqentry_exit(regs, state); ··· 298 298 unsigned long far = read_sysreg(far_el1); 299 299 irqentry_state_t state; 300 300 301 - state = enter_from_kernel_mode(regs); 301 + state = arm64_enter_from_kernel_mode(regs); 302 302 local_daif_inherit(regs); 303 303 do_mem_abort(far, esr, regs); 304 304 local_daif_mask(); 305 - exit_to_kernel_mode(regs, state); 305 + arm64_exit_to_kernel_mode(regs, state); 306 306 } 307 307 308 308 static void noinstr el1_pc(struct pt_regs *regs, unsigned long esr) ··· 310 310 unsigned long far = read_sysreg(far_el1); 311 311 irqentry_state_t state; 312 312 313 - state = enter_from_kernel_mode(regs); 313 + state = arm64_enter_from_kernel_mode(regs); 314 314 local_daif_inherit(regs); 315 315 do_sp_pc_abort(far, esr, regs); 316 316 local_daif_mask(); 317 - exit_to_kernel_mode(regs, state); 317 + arm64_exit_to_kernel_mode(regs, state); 318 318 } 319 319 320 320 static void noinstr el1_undef(struct pt_regs *regs, unsigned long esr) 321 321 { 322 322 irqentry_state_t state; 323 323 324 - state = enter_from_kernel_mode(regs); 324 + state = arm64_enter_from_kernel_mode(regs); 325 325 local_daif_inherit(regs); 326 326 do_el1_undef(regs, esr); 327 327 local_daif_mask(); 328 - exit_to_kernel_mode(regs, state); 328 + arm64_exit_to_kernel_mode(regs, state); 329 329 } 330 330 331 331 static void noinstr el1_bti(struct pt_regs *regs, unsigned long esr) 332 332 { 333 333 irqentry_state_t state; 334 334 335 - state = enter_from_kernel_mode(regs); 335 + state = arm64_enter_from_kernel_mode(regs); 336 336 local_daif_inherit(regs); 337 337 do_el1_bti(regs, esr); 338 338 local_daif_mask(); 339 - exit_to_kernel_mode(regs, state); 339 + arm64_exit_to_kernel_mode(regs, state); 340 340 } 341 341 342 342 static void noinstr el1_gcs(struct pt_regs *regs, unsigned long esr) 343 343 { 344 344 irqentry_state_t state; 345 345 346 - state = enter_from_kernel_mode(regs); 346 + state = arm64_enter_from_kernel_mode(regs); 347 347 local_daif_inherit(regs); 348 348 do_el1_gcs(regs, esr); 349 349 local_daif_mask(); 350 - exit_to_kernel_mode(regs, state); 350 + arm64_exit_to_kernel_mode(regs, state); 351 351 } 352 352 353 353 static void noinstr el1_mops(struct pt_regs *regs, unsigned long esr) 354 354 { 355 355 irqentry_state_t state; 356 356 357 - state = enter_from_kernel_mode(regs); 357 + state = arm64_enter_from_kernel_mode(regs); 358 358 local_daif_inherit(regs); 359 359 do_el1_mops(regs, esr); 360 360 local_daif_mask(); 361 - exit_to_kernel_mode(regs, state); 361 + arm64_exit_to_kernel_mode(regs, state); 362 362 } 363 363 364 364 static void noinstr el1_breakpt(struct pt_regs *regs, unsigned long esr) ··· 420 420 { 421 421 irqentry_state_t state; 422 422 423 - state = enter_from_kernel_mode(regs); 423 + state = arm64_enter_from_kernel_mode(regs); 424 424 local_daif_inherit(regs); 425 425 do_el1_fpac(regs, esr); 426 426 local_daif_mask(); 427 - exit_to_kernel_mode(regs, state); 427 + arm64_exit_to_kernel_mode(regs, state); 428 428 } 429 429 430 430 asmlinkage void noinstr el1h_64_sync_handler(struct pt_regs *regs) ··· 491 491 { 492 492 irqentry_state_t state; 493 493 494 - state = enter_from_kernel_mode(regs); 494 + state = arm64_enter_from_kernel_mode(regs); 495 495 496 496 irq_enter_rcu(); 497 497 do_interrupt_handler(regs, handler); 498 498 irq_exit_rcu(); 499 499 500 - exit_to_kernel_mode(regs, state); 500 + arm64_exit_to_kernel_mode(regs, state); 501 501 } 502 502 static void noinstr el1_interrupt(struct pt_regs *regs, 503 503 void (*handler)(struct pt_regs *))